Upload folder using huggingface_hub

app.py

@@ -1389,6 +1389,61 @@ def evaluation_tab():
     ], fluid=True, className="pt-3")
 
 
+def protocol_configs_tab():
+    _PC_FIELDS = ["expression_strain", "inducer", "medium_name",
+                  "plasmid", "lysis_buffer", "elution_buffer"]
+    _PC_LABELS = {
+        "expression_strain": "Expression host",
+        "inducer":           "Inducer",
+        "medium_name":       "Growth medium",
+        "plasmid":           "Plasmid",
+        "lysis_buffer":      "Lysis buffer",
+        "elution_buffer":    "Elution buffer",
+    }
+    topn_opts = [{"label": f"Top {n} clusters / field", "value": n}
+                 for n in [10, 20, 30, 50]]
+    return dbc.Container([
+        html.H3("Protocol Configurations", className="mt-3 mb-1"),
+        html.P(
+            "Most common multi-field protocol combinations derived from BioSimCSE clusters. "
+            "Each line in the flow diagram represents proteins sharing the same cluster "
+            "assignments across fields.",
+            className="text-muted mb-3",
+        ),
+        dbc.Row([
+            make_dropdown("Model", "pc-dd-model", MODELS,
+                          value="kamalkraj__BioSimCSE-BioLinkBERT-BASE"
+                          if "kamalkraj__BioSimCSE-BioLinkBERT-BASE" in MODELS
+                          else (MODELS[0] if MODELS else None)),
+            make_dropdown("Min community size", "pc-dd-min", MINS,
+                          value="2" if "2" in MINS else (MINS[0] if MINS else None)),
+            make_dropdown("Threshold", "pc-dd-threshold", THRESHOLDS,
+                          value="0.9" if "0.9" in THRESHOLDS else (THRESHOLDS[0] if THRESHOLDS else None)),
+            dbc.Col([
+                html.Label("Clusters per field", className="fw-semibold small mb-1"),
+                dcc.Dropdown(
+                    id="pc-dd-topn",
+                    options=topn_opts,
+                    value=20,
+                    clearable=False,
+                    style={"fontSize": "13px"},
+                ),
+            ]),
+        ], className="mb-3 g-2"),
+        dcc.Loading(
+            dcc.Graph(id="pc-parcats-graph", style={"height": "560px"}),
+            type="circle", color="#1a73e8",
+        ),
+        html.H5("Top configurations", className="mt-4 mb-2"),
+        html.P(
+            "Cluster labels are grouped into top-level categories (BL21, IPTG, LB, pET…) "
+            "to aggregate across fine-grained t=0.9 clusters. % is relative to all proteins with 4 core fields.",
+            className="text-muted small mb-2",
+        ),
+        dcc.Loading(html.Div(id="pc-config-table"), type="circle", color="#1a73e8"),
+    ], fluid=True, className="pt-3")
+
+
 def contact_tab():
     return dbc.Container([
         html.H3("Research Team", className="mt-3 mb-4"),
@@ -1748,8 +1803,9 @@ app.layout = dbc.Container([
     dbc.Tabs([
         dbc.Tab(label="Extraction Data",    tab_id="tab-proteins"),
         dbc.Tab(label="Clustering Explorer",tab_id="tab-clustering"),
-        dbc.Tab(label="Grid Metrics",       tab_id="tab-grid-metrics"),
-        dbc.Tab(label="Evaluation Results", tab_id="tab-evaluation"),
+        dbc.Tab(label="Grid Metrics",           tab_id="tab-grid-metrics"),
+        dbc.Tab(label="Protocol Configurations",tab_id="tab-protocol-configs"),
+        dbc.Tab(label="Evaluation Results",     tab_id="tab-evaluation"),
         dbc.Tab(label="Extraction Pipeline Instructions", tab_id="tab-pipeline"),
         dbc.Tab(label="README",             tab_id="tab-readme"),
         dbc.Tab(label="Contact",            tab_id="tab-contact"),
@@ -1773,6 +1829,8 @@ def render_tab(tab):
         return clustering_tab()
     elif tab == "tab-grid-metrics":
         return grid_metrics_tab()
+    elif tab == "tab-protocol-configs":
+        return protocol_configs_tab()
     elif tab == "tab-evaluation":
         return evaluation_tab()
     elif tab == "tab-pipeline":
@@ -2734,6 +2792,217 @@ def update_metrics_table(model, min_val, threshold):
     )
 
 
+_PC_PROTOCOL_FIELDS = ["expression_strain", "inducer", "medium_name",
+                       "plasmid", "lysis_buffer", "elution_buffer"]
+_PC_FIELD_LABELS = {
+    "expression_strain": "Expression host",
+    "inducer":           "Inducer",
+    "medium_name":       "Growth medium",
+    "plasmid":           "Plasmid",
+    "lysis_buffer":      "Lysis buffer",
+    "elution_buffer":    "Elution buffer",
+}
+_PC_COLORS = [
+    "#1a73e8", "#4db8ff", "#80ccff", "#1aa85c", "#f4a55a",
+    "#e8711a", "#c0392b", "#8e1ae8", "#2ecc71", "#adb5bd",
+    "#dee2e6",
+]
+
+
+def _pc_build_wide(all_fields_df, top_n):
+    """Pivot ALL_FIELDS into wide format, keeping top_n clusters per field."""
+    sub = all_fields_df[all_fields_df["field"].isin(_PC_PROTOCOL_FIELDS)].copy()
+    rows = []
+    for field in _PC_PROTOCOL_FIELDS:
+        fd = sub[sub["field"] == field]
+        clustered = fd[fd["cluster_id"] != -1]
+        # Top N clusters by size
+        top_ids = (
+            clustered.groupby("cluster_id").size()
+            .sort_values(ascending=False)
+            .head(top_n).index
+        )
+        def label_row(r):
+            if r["cluster_id"] == -1:
+                return None
+            if r["cluster_id"] in top_ids:
+                lbl = r["cluster_label_short"]
+                return lbl[:40] + "…" if len(lbl) > 40 else lbl
+            return "Other clusters"
+        fd = fd.copy()
+        fd["cat"] = fd.apply(label_row, axis=1)
+        rows.append(fd[["key", "protein_index", "cat"]].rename(columns={"cat": field}))
+
+    wide = rows[0]
+    for r in rows[1:]:
+        wide = wide.merge(r, on=["key", "protein_index"], how="outer")
+    return wide
+
+
+@app.callback(
+    Output("pc-parcats-graph", "figure"),
+    Output("pc-config-table", "children"),
+    Input("pc-dd-model", "value"),
+    Input("pc-dd-min", "value"),
+    Input("pc-dd-threshold", "value"),
+    Input("pc-dd-topn", "value"),
+)
+def update_protocol_configs(model, min_val, threshold, top_n):
+    if not all([model, min_val, threshold, top_n]):
+        empty = go.Figure()
+        empty.update_layout(paper_bgcolor="white",
+                            annotations=[dict(text="Select model, min and threshold.",
+                                              showarrow=False, font=dict(size=14))])
+        return empty, html.Div()
+
+    adf = _load_cluster_csv(model, min_val, threshold)
+    if adf is None:
+        empty = go.Figure()
+        empty.update_layout(paper_bgcolor="white",
+                            annotations=[dict(text="Data file not found.",
+                                              showarrow=False, font=dict(size=14))])
+        return empty, html.Div("Data file not found.", className="text-muted small")
+
+    wide = _pc_build_wide(adf, top_n)
+    core = _PC_PROTOCOL_FIELDS[:4]   # host, inducer, medium, plasmid
+    w4 = wide.dropna(subset=core)
+
+    # ── Parcats figure ──────────────────────────────────────────────────────
+    dims = []
+    for field in _PC_PROTOCOL_FIELDS:
+        if field not in wide.columns:
+            continue
+        col = w4[field].fillna("N/A") if field in w4.columns else None
+        if col is None:
+            continue
+        from collections import Counter as _Ctr
+        cnt = _Ctr(col.tolist())
+        cat_order = [c for c, _ in cnt.most_common() if c != "N/A"] + ["N/A"]
+        dims.append(go.parcats.Dimension(
+            values=col.tolist(),
+            label=_PC_FIELD_LABELS.get(field, field),
+            categoryorder="array",
+            categoryarray=cat_order,
+        ))
+
+    # Color by expression host category index
+    host_col = w4["expression_strain"].fillna("N/A").tolist()
+    all_hosts = list(dict.fromkeys(host_col))
+    host_idx  = {h: i for i, h in enumerate(all_hosts)}
+    color_vals = [host_idx.get(h, 0) for h in host_col]
+    n_hosts = max(len(all_hosts), 1)
+    colorscale = [[i / max(n_hosts - 1, 1), _PC_COLORS[i % len(_PC_COLORS)]]
+                  for i in range(n_hosts)]
+
+    fig = go.Figure(go.Parcats(
+        dimensions=dims,
+        line=dict(color=color_vals, colorscale=colorscale, shape="hspline"),
+        labelfont=dict(size=12, family="Arial"),
+        tickfont=dict(size=10, family="Arial"),
+        arrangement="freeform",
+        hoverinfo="count+probability",
+    ))
+    short_model = model.split("__")[-1] if "__" in model else model
+    fig.update_layout(
+        title=dict(
+            text=f"Protocol configuration flows — {short_model}  t={threshold}  min={min_val}",
+            font=dict(size=13, family="Arial"), x=0.5,
+        ),
+        paper_bgcolor="white",
+        font=dict(family="Arial", size=11),
+        margin=dict(l=60, r=60, t=60, b=40),
+    )
+
+    # ── Top-config table — category-level grouping ──────────────────────────
+    # Map fine-grained cluster labels to readable top-level categories so
+    # combinations survive the specificity of t=0.9 clusters.
+    def _grp(field, label):
+        if not label or label == "Other clusters":
+            return None
+        sl = str(label).lower()
+        if field == "expression_strain":
+            if "bl21" in sl:             return "BL21(DE3)"
+            if "rosetta" in sl:          return "Rosetta"
+            if "c41" in sl or "c43" in sl: return "C41/C43"
+            if "hek" in sl or "cho" in sl or "293" in sl: return "Human/CHO"
+            if "sf9" in sl or "sf21" in sl: return "Insect (Sf9)"
+            if "yeast" in sl or "pichia" in sl: return "Yeast"
+            return "Other E. coli"
+        if field == "inducer":
+            if "not mentioned" in sl:    return "IPTG (implied)"
+            if "iptg" in sl:             return "IPTG"
+            if "arabinose" in sl:        return "Arabinose"
+            return "Other inducer"
+        if field == "medium_name":
+            if re.search(r"\blb\b|luria.bertani|luria broth", sl): return "LB"
+            if "terrific" in sl:         return "TB"
+            if "2xyt" in sl or "2x yt" in sl: return "2xYT"
+            if "minimal" in sl or "m9" in sl: return "Minimal"
+            return "Other medium"
+        if field == "plasmid":
+            if re.search(r"\bpet", sl):  return "pET"
+            if "pgex" in sl:             return "pGEX"
+            if "pqe" in sl:              return "pQE"
+            if "pmal" in sl:             return "pMAL"
+            return "Other plasmid"
+        if field == "lysis_buffer":
+            if re.search(r"\btris\b", sl): return "Tris"
+            if "pbs" in sl:              return "PBS"
+            if "hepes" in sl:            return "HEPES"
+            if re.search(r"\bphosphate\b", sl): return "Phosphate"
+            return "Other lysis"
+        if field == "elution_buffer":
+            if "imidazole" in sl:        return "Imidazole"
+            if "glutathione" in sl:      return "Glutathione"
+            if "maltose" in sl:          return "Maltose"
+            return "Other elution"
+        return label
+
+    # Build category table from all clustered entries (not just top-N)
+    # to get meaningful combination counts.
+    sub_all = adf[adf["field"].isin(core) & (adf["cluster_id"] != -1)].copy()
+    sub_all["cat"] = sub_all.apply(
+        lambda r: _grp(r["field"], r["cluster_label_short"]), axis=1
+    )
+    sub_all = sub_all[sub_all["cat"].notna()]
+    wide_cat = sub_all.pivot_table(
+        index=["key", "protein_index"], columns="field",
+        values="cat", aggfunc="first"
+    ).reset_index()
+    w4_grp = wide_cat.dropna(subset=core)
+    from collections import Counter as _Ctr
+    combos = _Ctr(tuple(r) for r in w4_grp[core].itertuples(index=False))
+    total  = len(w4_grp)   # proteins with all 4 fields in a named cluster
+
+    table_rows = []
+    for rank, (combo, cnt) in enumerate(combos.most_common(20), 1):
+        row = {"Rank": rank, "Count": cnt, "%": f"{cnt/total*100:.1f}%"}
+        for field, val in zip(core, combo):
+            row[_PC_FIELD_LABELS[field]] = val
+        table_rows.append(row)
+
+    cols = ["Rank", "Count", "%"] + [_PC_FIELD_LABELS[f] for f in core]
+    table = dash_table.DataTable(
+        columns=[{"name": c, "id": c} for c in cols],
+        data=table_rows,
+        sort_action="native",
+        style_table={"overflowX": "auto"},
+        style_cell={"fontSize": "12px", "padding": "5px 10px", "textAlign": "left",
+                    "maxWidth": "220px", "overflow": "hidden", "textOverflow": "ellipsis"},
+        style_header={"fontWeight": "bold", "backgroundColor": "#f8f9fa"},
+        style_data_conditional=[
+            {"if": {"row_index": "odd"}, "backgroundColor": "#f8f9fa"},
+            {"if": {"row_index": 0},     "backgroundColor": "#e8f0fe", "fontWeight": "600"},
+        ],
+        tooltip_data=[
+            {c: {"value": str(row.get(c, "")), "type": "markdown"} for c in cols}
+            for row in table_rows
+        ],
+        tooltip_duration=None,
+    )
+    return fig, table
+
+
 @app.callback(
     Output("metrics-heatmap", "figure"),
     Output("metrics-model-compare", "figure"),