Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,644 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import io
+import re
+import numpy as np
+import openpyxl
+import base64
+
+# =========================
+# Streamlit App Setup
+# =========================
+st.set_page_config(page_title="DNA ↔ Binary Converter", layout="wide")
+st.title("DNA ↔ Binary Converter")
+
+# =========================
+# Encoding Schemes
+# =========================
+ENCODING_OPTIONS = ["Voyager 6-bit", "Base64 (6-bit)", "ASCII (7-bit)", "UTF-8 (8-bit)"]
+
+BITS_PER_UNIT = {
+    "Voyager 6-bit": 6,
+    "Base64 (6-bit)": 6,
+    "ASCII (7-bit)": 7,
+    "UTF-8 (8-bit)": 8,
+}
+
+# =========================
+# Voyager ASCII 6-bit Table
+# =========================
+voyager_table = {
+    i: ch for i, ch in enumerate([
+        ' ', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
+        'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
+        'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2',
+        '3', '4', '5', '6', '7', '8', '9', '.', ',', '(',
+        ')','+', '-', '*', '/', '=', '$', '!', ':', '%',
+        '"', '#', '@', "'", '?', '&'
+    ])
+}
+reverse_voyager_table = {v: k for k, v in voyager_table.items()}
+
+B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+
+# =========================
+# Encoding Functions
+# =========================
+def encode_to_binary(text: str, scheme: str) -> tuple[list[int], list[str]]:
+    """
+    Returns (flat_bits, display_units).
+    display_units is a list of labels for each chunk (character, byte, or Base64 symbol).
+    """
+    if scheme == "Voyager 6-bit":
+        bits = []
+        for char in text:
+            val = reverse_voyager_table.get(char.upper(), 0)
+            bits.extend([(val >> b) & 1 for b in range(5, -1, -1)])
+        return bits, list(text.upper())
+
+    elif scheme == "ASCII (7-bit)":
+        bits = []
+        for c in text:
+            val = ord(c) & 0x7F
+            bits.extend([(val >> b) & 1 for b in range(6, -1, -1)])
+        return bits, list(text)
+
+    elif scheme == "UTF-8 (8-bit)":
+        raw = text.encode("utf-8")
+        bits = []
+        for byte in raw:
+            bits.extend([(byte >> b) & 1 for b in range(7, -1, -1)])
+        # For display: show hex byte value and the character it belongs to
+        labels = [f"0x{b:02X}" for b in raw]
+        return bits, labels
+
+    elif scheme == "Base64 (6-bit)":
+        b64_str = base64.b64encode(text.encode("utf-8")).decode("ascii")
+        bits = []
+        clean = b64_str.rstrip("=")
+        for c in clean:
+            val = B64_ALPHABET.index(c)
+            bits.extend([(val >> b) & 1 for b in range(5, -1, -1)])
+        return bits, list(clean)
+
+    return [], []
+
+
+# =========================
+# Decoding Functions
+# =========================
+def decode_from_binary(bits: list[int], scheme: str) -> str:
+    if scheme == "Voyager 6-bit":
+        chars = []
+        for i in range(0, len(bits), 6):
+            chunk = bits[i:i + 6]
+            if len(chunk) < 6:
+                chunk += [0] * (6 - len(chunk))
+            val = sum(b << (5 - j) for j, b in enumerate(chunk))
+            chars.append(voyager_table.get(val, '?'))
+        return ''.join(chars)
+
+    elif scheme == "ASCII (7-bit)":
+        chars = []
+        for i in range(0, len(bits), 7):
+            chunk = bits[i:i + 7]
+            if len(chunk) < 7:
+                chunk += [0] * (7 - len(chunk))
+            val = sum(b << (6 - j) for j, b in enumerate(chunk))
+            chars.append(chr(val) if 32 <= val < 127 else '?')
+        return ''.join(chars)
+
+    elif scheme == "UTF-8 (8-bit)":
+        byte_list = []
+        for i in range(0, len(bits), 8):
+            chunk = bits[i:i + 8]
+            if len(chunk) < 8:
+                chunk += [0] * (8 - len(chunk))
+            val = sum(b << (7 - j) for j, b in enumerate(chunk))
+            byte_list.append(val)
+        return bytes(byte_list).decode("utf-8", errors="replace")
+
+    elif scheme == "Base64 (6-bit)":
+        chars = []
+        for i in range(0, len(bits), 6):
+            chunk = bits[i:i + 6]
+            if len(chunk) < 6:
+                chunk += [0] * (6 - len(chunk))
+            val = sum(b << (5 - j) for j, b in enumerate(chunk))
+            chars.append(B64_ALPHABET[val])
+        b64_str = ''.join(chars)
+        # Add Base64 padding
+        while len(b64_str) % 4 != 0:
+            b64_str += '='
+        try:
+            return base64.b64decode(b64_str).decode("utf-8", errors="replace")
+        except Exception:
+            return "[Base64 decode error]"
+
+    return ""
+
+
+# =========================
+# Tabs
+# =========================
+tab1, tab2, tab3 = st.tabs(["Encoding", "Decoding", "Writing"])
+
+# --------------------------------------------------
+# TAB 1: Text → Binary
+# --------------------------------------------------
+with tab1:
+    st.markdown("""
+    Convert any text into binary labels.  
+    Choose an encoding scheme and control how many positions (columns) are grouped per row.
+    """)
+
+    st.subheader("Step 1 – Choose Encoding & Input Text")
+
+    encoding_scheme = st.selectbox(
+        "Encoding scheme:",
+        ENCODING_OPTIONS,
+        index=0,
+        key="enc_scheme",
+        help=(
+            "**Voyager 6-bit** – Custom 56-character table (A-Z, 0-9, punctuation). 6 bits/char.\n\n"
+            "**Base64 (6-bit)** – Standard Base64 encoding of UTF-8 bytes. 6 bits/symbol.\n\n"
+            "**ASCII (7-bit)** – Standard 7-bit ASCII. 7 bits/char.\n\n"
+            "**UTF-8 (8-bit)** – Full UTF-8 byte encoding. 8 bits/byte. Supports all Unicode."
+        )
+    )
+
+    bits_per = BITS_PER_UNIT[encoding_scheme]
+
+    # Show a note for Voyager about supported characters
+    if encoding_scheme == "Voyager 6-bit":
+        supported = ''.join(voyager_table[i] for i in range(len(voyager_table)))
+        st.caption(f"Supported characters ({len(voyager_table)}): `{supported}`")
+
+    user_input = st.text_input("Enter your text:", value="DNA", key="input_text")
+
+    col1, col2 = st.columns([2, 1])
+    with col1:
+        group_size = st.slider("Select number of target positions:", min_value=12, max_value=128, value=25)
+    with col2:
+        custom_cols = st.number_input("Or enter custom number:", min_value=1, max_value=512, value=group_size)
+    if custom_cols != group_size:
+        group_size = custom_cols
+
+    if user_input:
+        binary_labels, display_units = encode_to_binary(user_input, encoding_scheme)
+        binary_concat = ''.join(map(str, binary_labels))
+
+        # --- Output 1: Binary Labels per Unit ---
+        unit_label = "Byte" if encoding_scheme == "UTF-8 (8-bit)" else "Character"
+        st.markdown(f"### Output 1 – Binary Labels per {unit_label}")
+        st.caption(f"Encoding: **{encoding_scheme}** — {bits_per} bits per {unit_label.lower()}")
+
+        grouped_bits = [binary_labels[i:i + bits_per] for i in range(0, len(binary_labels), bits_per)]
+        scroll_html = (
+            "<div style='max-height:300px; overflow-y:auto; font-family:monospace; "
+            "padding:6px; border:1px solid #ccc;'>"
+        )
+        for i, bits in enumerate(grouped_bits):
+            label = display_units[i] if i < len(display_units) else "?"
+            scroll_html += f"<div>'{label}' → {bits}</div>"
+        scroll_html += "</div>"
+        st.markdown(scroll_html, unsafe_allow_html=True)
+
+        # Download per-character breakdown
+        per_char_lines = []
+        for i, bits in enumerate(grouped_bits):
+            label = display_units[i] if i < len(display_units) else "?"
+            per_char_lines.append(f"'{label}' → {''.join(map(str, bits))}")
+        st.download_button(
+            f"⬇️ Download Binary per {unit_label} (.txt)",
+            data='\n'.join(per_char_lines),
+            file_name="binary_per_unit.txt",
+            mime="text/plain",
+            key="download_per_unit"
+        )
+
+        # Download full concatenated binary text
+        st.download_button(
+            "⬇️ Download Concatenated Binary String",
+            data=binary_concat,
+            file_name="binary_full.txt",
+            mime="text/plain",
+            key="download_binary_txt"
+        )
+
+        # --- Output 2: Grouped Binary Matrix ---
+        st.markdown("### Output 2 – Grouped Binary Matrix")
+        groups = []
+        for i in range(0, len(binary_labels), group_size):
+            group = binary_labels[i:i + group_size]
+            if len(group) < group_size:
+                group += [0] * (group_size - len(group))
+            groups.append(group)
+
+        columns = [f"Position {i+1}" for i in range(group_size)]
+        df = pd.DataFrame(groups, columns=columns)
+        st.dataframe(df, use_container_width=True)
+
+        st.download_button(
+            "⬇️ Download as CSV",
+            df.to_csv(index=False),
+            file_name=f"binary_labels_{group_size}_positions.csv",
+            mime="text/csv",
+            key="download_binary_csv"
+        )
+    else:
+        st.info("👆 Enter text above to see binary labels.")
+
+# --------------------------------------------------
+# TAB 2: Binary → Text
+# --------------------------------------------------
+with tab2:
+    st.markdown("""
+    Convert binary data back into readable text.  
+    Upload either:
+    - `.csv` file with 0/1 values (any number of columns/rows)  
+    - `.xlsx` Excel file  
+    - `.txt` file containing a concatenated binary string (e.g. `010101...`)
+    """)
+
+    decode_scheme = st.selectbox(
+        "Decoding scheme (must match the encoding used):",
+        ENCODING_OPTIONS,
+        index=0,
+        key="dec_scheme",
+        help="Select the same encoding scheme that was used to produce the binary data."
+    )
+
+    uploaded_decode = st.file_uploader(
+        "Upload your file (.csv, .xlsx, or .txt):",
+        type=["csv", "xlsx", "txt"],
+        key="decode_uploader"
+    )
+
+    if uploaded_decode is not None:
+        try:
+            if uploaded_decode.name.endswith(".csv"):
+                df = pd.read_csv(uploaded_decode)
+                bits = df.values.flatten().astype(int).tolist()
+            elif uploaded_decode.name.endswith(".xlsx"):
+                df = pd.read_excel(uploaded_decode)
+                bits = df.values.flatten().astype(int).tolist()
+            elif uploaded_decode.name.endswith(".txt"):
+                content = uploaded_decode.read().decode().strip()
+                bits = [int(b) for b in content if b in ['0', '1']]
+            else:
+                bits = []
+
+            if not bits:
+                st.warning("No binary data detected.")
+            else:
+                recovered_text = decode_from_binary(bits, decode_scheme)
+                st.success(f"✅ Conversion complete using **{decode_scheme}**!")
+                st.markdown("**Recovered text:**")
+                st.text_area("Output", recovered_text, height=150)
+
+                st.download_button(
+                    "⬇️ Download Recovered Text (.txt)",
+                    data=recovered_text,
+                    file_name="recovered_text.txt",
+                    mime="text/plain",
+                    key="download_recovered"
+                )
+        except Exception as e:
+            st.error(f"Error reading or converting file: {e}")
+    else:
+        st.info("👆 Upload a file to start the reverse conversion.")
+
+# --------------------------------------------------
+# TAB 3: Pipetting Command Generator
+# --------------------------------------------------
+with tab3:
+    from math import ceil
+
+    st.header("🧪 Pipetting Command Generator for Eppendorf epMotion liquid handler")
+    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  
+    - Let you set the **Desired total volume per sample (µL)** used to compute `Volume per "1"`  
+    - Calculate total demand per input and suggest a **uniform layout** (same # consecutive wells per input)  
+    - **Preview** the layout on a plate map (with tooltips)  
+    - After confirmation, generate pipetting commands and a source volume summary  
+    """)
+
+    uploaded_writing = st.file_uploader(
+        "📤 Upload data file",
+        type=["xlsx", "csv", "txt"],
+        key="writing_uploader"
+    )
+    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, parsing, 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():
+        for r in ROWS_96:
+            for c in COLS_96:
+                yield f"{r}{c}"
+
+    def parse_well_name(well: str):
+        m = re.match(r"([A-Ha-h])\s*([0-9]+)", str(well).strip())
+        if not m:
+            return ("A", 0)
+        return (m.group(1).upper(), int(m.group(2)))
+
+    def sample_index_to_plate_and_well(sample_idx: int):
+        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"
+
+    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):
+        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 = """
+        <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]
+        for p in range(1, plates_used + 1):
+            body.append(f"<div class='plate'><div class='plate-title'>Plate {p}</div>")
+            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>")
+            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>")
+        return "".join(body)
+
+    # ---------- Main flow ----------
+    if uploaded_writing is not None:
+        try:
+            if uploaded_writing.name.endswith(".xlsx"):
+                df = pd.read_excel(uploaded_writing)
+            elif uploaded_writing.name.endswith(".csv"):
+                df = pd.read_csv(uploaded_writing)
+            else:
+                try:
+                    df = pd.read_csv(uploaded_writing, sep="\t")
+                except Exception:
+                    df = pd.read_csv(uploaded_writing)
+
+            st.success(f"✅ Loaded file with {len(df)} rows and {len(df.columns)} columns")
+
+            df.columns = [str(c).strip() for c in df.columns]
+
+            if not any(c.lower() == "sample" for c in df.columns):
+                df.insert(0, "Sample", np.arange(1, len(df) + 1))
+                st.info("`Sample` column missing — automatically generated 1..N.")
+
+            position_cols = [c for c in df.columns if re.match(r"(?i)^position\s*\d+", c)]
+            if not position_cols:
+                non_pos_cols = {"sample", "total edited", 'volume per "1"', "volume per 1"}
+                candidate_cols = [c for c in df.columns if c.lower() not in non_pos_cols]
+                position_cols = candidate_cols
+                st.info(f"Position columns inferred automatically: {len(position_cols)} detected.")
+
+            def pos_key(col_name: str):
+                m = re.search(r"(\d+)", col_name)
+                return int(m.group(1)) if m else 10**9
+            position_cols = sorted(position_cols, key=pos_key)
+
+            df[position_cols] = df[position_cols].apply(pd.to_numeric, errors="coerce").fillna(0).astype(int)
+
+            if "Total edited" not in df.columns:
+                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.")
+
+            st.markdown("#### ⚙️ Volume Calculation Settings")
+            default_total_vol = st.number_input(
+                "Desired total volume per sample (µL)",
+                min_value=1.0, max_value=10000.0, value=64.0, step=1.0,
+                help="Used to compute Volume per '1' as (Desired total volume / Total edited) when not provided."
+            )
+
+            vol_candidates = [c for c in df.columns if "volume per" in c.lower()]
+            if not vol_candidates:
+                df['Volume per "1"'] = default_total_vol / df["Total edited"].replace(0, np.nan)
+                df['Volume per "1"'] = df['Volume per "1"'].fillna(0)
+                st.info(f'`Volume per "1"` column missing — calculated automatically as {default_total_vol:.0f} µL / Total edited.')
+                volume_col = 'Volume per "1"'
+            else:
+                volume_col = vol_candidates[0]
+
+            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()
+
+            vol_per_one_series = pd.to_numeric(df[volume_col], errors="coerce").fillna(0.0)
+            total_volume_per_input = [float(vol_per_one_series[df[pos] == 1].sum()) for pos in position_cols]
+            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 — 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_needed_uniform = num_inputs * max_wells_per_source
+            plates_needed = int(ceil(total_wells_needed_uniform / 96)) or 1
+
+            global_wells = sorted(
+                build_global_wells_list(plates_needed),
+                key=lambda x: (
+                    x[0],
+                    ROWS_96.index(parse_well_name(x[1])[0]),
+                    parse_well_name(x[1])[1]
+                )
+            )
+            global_wells = global_wells[:total_wells_needed_uniform]
+
+            assigned_wells_map, well_to_input, preview_rows = {}, {}, []
+            for i in range(1, num_inputs + 1):
+                start, end = (i - 1) * max_wells_per_source, i * 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)
+                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)
+
+            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)
+
+            st.markdown("### ✅ Generate Pipetting Commands")
+            if st.button("Generate using this layout"):
+                per_input_well_cum = {i: [0.0] * max_wells_per_source for i in range(1, num_inputs + 1)}
+                commands, source_volume_totals = [], {}
+
+                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]
+
+                        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 chosen is None:
+                            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()
+
+                        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({
+                            "Input #": 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
+                        })
+
+                commands_df = pd.DataFrame(commands)
+
+                def row_idx_from_well(w): return ROWS_96.index(parse_well_name(w)[0])
+                def col_num_from_well(w): return parse_well_name(w)[1]
+
+                commands_df["Src_row_idx"] = commands_df["Source well"].apply(row_idx_from_well)
+                commands_df["Src_col_num"] = commands_df["Source well"].apply(col_num_from_well)
+                commands_df["Dst_row_idx"] = commands_df["Destination well"].apply(row_idx_from_well)
+                commands_df["Dst_col_num"] = commands_df["Destination well"].apply(col_num_from_well)
+
+                commands_df = commands_df.sort_values(
+                    by=["Input #", "Source plate", "Src_row_idx", "Src_col_num",
+                        "Destination plate", "Dst_row_idx", "Dst_col_num"],
+                    kind="stable"
+                )
+
+                commands_df = commands_df[[
+                    "Input #", "Source plate", "Source well",
+                    "Destination plate", "Destination well", "Volume", "Tool"
+                ]]
+
+                st.success(f"✅ Generated {len(commands_df)} commands across {num_inputs} inputs.")
+
+                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)
+                summary_df["Src_row_idx"] = summary_df["Source well"].apply(row_idx_from_well)
+                summary_df["Src_col_num"] = summary_df["Source well"].apply(col_num_from_well)
+                summary_df = summary_df.sort_values(
+                    by=["Source", "Source plate", "Src_row_idx", "Src_col_num"],
+                    kind="stable"
+                )[
+                    ["Source", "Source plate", "Source well", "Total volume taken (µL)", "Allocated capacity (µL)"]
+                ]
+
+                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")
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+        except Exception as e:
+            st.error(f"❌ Error processing file: {e}")
+    else:
+        st.info("👆 Upload an Excel/CSV/TXT file to start.")