"""ProtHGT — guided three-step interface (add proteins → choose what to predict → review results).""" import os import random import re import streamlit as st st.set_page_config( page_title="ProtHGT · Protein function prediction", page_icon="🧬", layout="wide", initial_sidebar_state="collapsed", ) from rapidfuzz import fuzz, process from run_prothgt_app import KG_PATH, generate_prediction_df, load_kg, load_model, load_name_info from run_prothgt_ec_app import EC_KG_PATH, generate_ec_prediction_df, load_ec_kg, load_ec_model from visualize_kg import visualize_protein_subgraph from ui import GITHUB_URL, KG_VIEW_GUIDE, STRICTNESS, render_header, render_stepper # --------------------------------------------------------------------------- # Settings # --------------------------------------------------------------------------- MAX_PROTEINS = 100 MAX_KG_VIZ_PROTEINS = 10 SEARCH_LIMIT = 50 KG_DOWNLOAD_URL = "https://huggingface.co/datasets/HUBioDataLab/ProtHGT/blob/main/knowledge_graphs/go/prothgt-kg.pt" ASPECTS = { "GO_term_F": ("Molecular function", "What the protein does at the molecular level, e.g. binding or catalysis."), "GO_term_P": ("Biological process", "Which larger pathways or programs it takes part in."), "GO_term_C": ("Cellular component", "Where in the cell the protein is located."), } ASPECT_SHORT = {"GO_term_F": "MF", "GO_term_P": "BP", "GO_term_C": "CC"} CATEGORY_TO_KEY = {"Molecular Function": "GO_term_F", "Biological Process": "GO_term_P", "Cellular Component": "GO_term_C"} # Widget values that must survive moving between steps (Streamlit drops the state of # widgets that are not rendered; re-assigning keeps it). PERSISTENT_KEYS = ["proteins", "aspect_GO_term_F", "aspect_GO_term_P", "aspect_GO_term_C", "predict_ec", "strictness", "use_custom_threshold", "custom_threshold"] for _k in PERSISTENT_KEYS: if _k in st.session_state: st.session_state[_k] = st.session_state[_k] DEFAULTS = { "step": 1, "proteins": [], "aspect_GO_term_F": True, "aspect_GO_term_P": True, "aspect_GO_term_C": True, "predict_ec": False, "strictness": "Balanced", "use_custom_threshold": False, "custom_threshold": 0.50, "notice": None, "results": None, "results_cache": {}, "viz": {}, } for _k, _v in DEFAULTS.items(): st.session_state.setdefault(_k, _v) # --------------------------------------------------------------------------- # Cached heavy resources (shared by every visitor of the Space, loaded once) # --------------------------------------------------------------------------- @st.cache_resource(show_spinner=False) def get_protein_names(): """UniProt ID -> protein name, for every protein in the knowledge graph.""" return load_name_info()["Protein"] @st.cache_resource(show_spinner=False) def get_search_index(): """(id, lower-cased name) pairs plus fuzzy-match choices, built once per process.""" names = get_protein_names() lowered = [(pid, name.lower()) for pid, name in names.items()] choices = {pid: f"{pid} {name}" for pid, name in names.items()} return lowered, choices @st.cache_resource(show_spinner=False) def get_kg(): return load_kg() @st.cache_resource(show_spinner=False) def get_model(go_cat): return load_model(go_cat, get_kg()) @st.cache_resource(show_spinner=False) def get_ec_kg(): return load_ec_kg() @st.cache_resource(show_spinner=False) def get_ec_model(): return load_ec_model(get_ec_kg()) @st.cache_data(show_spinner=False, max_entries=200) def search_proteins(query): """Exact ID → ID prefix → name substring (closest names first) → fuzzy fallback.""" q = query.strip() qu, ql = q.upper(), q.lower() names = get_protein_names() lowered, choices = get_search_index() hits = [qu] if qu in names else [] if re.fullmatch(r"[A-Za-z0-9_]+", q): hits += sorted(pid for pid, _ in lowered if pid.startswith(qu))[:SEARCH_LIMIT] substr = [(name != ql, len(name), pid) for pid, name in lowered if ql in name] hits += [pid for _, _, pid in sorted(substr)[:SEARCH_LIMIT]] if len(hits) < SEARCH_LIMIT: hits += [m[2] for m in process.extract(q, choices, scorer=fuzz.WRatio, limit=SEARCH_LIMIT)] return list(dict.fromkeys(hits))[:SEARCH_LIMIT] # --------------------------------------------------------------------------- # State helpers / callbacks # --------------------------------------------------------------------------- def go_to(step): st.session_state.step = step def selected_aspects(): return [k for k in ASPECTS if st.session_state[f"aspect_{k}"]] def current_threshold(): if st.session_state.use_custom_threshold: return float(st.session_state.custom_threshold) return STRICTNESS[st.session_state.strictness][0] def add_proteins(candidates, source): names = get_protein_names() candidates = list(dict.fromkeys(c.strip().upper() for c in candidates if c and c.strip())) known = [c for c in candidates if c in names] unknown = [c for c in candidates if c not in names] current = list(st.session_state.proteins) new = [p for p in known if p not in current] room = MAX_PROTEINS - len(current) dropped = new[room:] if room < len(new) else [] current.extend(new[:max(room, 0)]) st.session_state.proteins = current st.session_state.notice = { "source": source, "added": len(new) - len(dropped), "duplicates": len(known) - len(new), "unknown": unknown, "over_limit": dropped, } def add_from_paste(): text = st.session_state.get("paste_text", "") add_proteins(re.split(r"[\s,;]+", text), "pasted list") def add_from_search(): add_proteins(st.session_state.get("search_pick", []), "search") st.session_state.search_pick = [] def add_from_file(): uploaded = st.session_state.get("upload_file") if uploaded is None: return text = uploaded.getvalue().decode("utf-8", errors="ignore") add_proteins(re.split(r"[\s,;]+", text), uploaded.name) def add_example(): pool = list(get_protein_names().keys()) add_proteins(random.sample(pool, 5), "example set") def clear_proteins(): st.session_state.proteins = [] st.session_state.notice = None def clear_visualizations(): for path in st.session_state.viz.values(): try: os.unlink(path["path"]) except OSError: pass st.session_state.viz = {} def start_new_prediction(): st.session_state.results = None st.session_state.results_cache = {} st.session_state.notice = None clear_visualizations() go_to(1) # --------------------------------------------------------------------------- # Page # --------------------------------------------------------------------------- render_header() step = st.session_state.step hero_slot = st.empty() # always created so the elements below keep a stable position across steps if step < 3: hero_slot.markdown( '

Protein function prediction with knowledge graphs

' "

Gene Ontology term and Enzyme Commission number predictions from a heterogeneous graph " "transformer that combines protein language model embeddings with a large-scale biological " "knowledge graph.

", unsafe_allow_html=True, ) else: hero_slot.markdown('
', unsafe_allow_html=True) render_stepper(step) def protein_chips_html(proteins, limit=40): shown = "".join(f'{p}' for p in proteins[:limit]) more = f'+{len(proteins) - limit} more' if len(proteins) > limit else "" return f'
{shown}{more}
' def render_limit_aside(): n = len(st.session_state.proteins) with st.container(border=True): st.markdown("**Your proteins**") if n: st.markdown(protein_chips_html(st.session_state.proteins), unsafe_allow_html=True) else: st.markdown('None added yet.', unsafe_allow_html=True) st.markdown( f'
' f'{n} of {MAX_PROTEINS} proteins per run', unsafe_allow_html=True, ) if step == 2: st.button("Edit proteins", on_click=go_to, args=(1,), use_container_width=True) with st.container(border=True): st.markdown("**Need more than 100?**") st.markdown( f'Run ProtHGT locally with the code and pretrained models on ' f'GitHub.', unsafe_allow_html=True, ) # --------------------------------------------------------------------------- # Step 1 — add proteins # --------------------------------------------------------------------------- def render_step_1(): main, aside = st.columns([2.3, 1], gap="large") with main: with st.container(border=True): st.subheader("Which proteins do you want to annotate?") st.caption("ProtHGT works on the ~326K UniProtKB/Swiss-Prot proteins in its knowledge graph. " "Up to 100 proteins per run.") paste_tab, search_tab, upload_tab, example_tab = st.tabs( ["Paste IDs", "Search", "Upload file", "Try an example"]) with paste_tab: with st.form("paste_form", clear_on_submit=True, border=False): st.text_area( "UniProt accessions", key="paste_text", placeholder="P69905, P68871\nQ9Y6K9", help="Separate IDs with commas, spaces or new lines.", height=110, ) st.form_submit_button("Add proteins", on_click=add_from_paste) with search_tab: query = st.text_input( "Search by UniProt ID or protein name", key="search_q", placeholder="e.g. hemoglobin, kinase, P699…", ) if len(query.strip()) >= 3: names = get_protein_names() with st.spinner("Searching…"): hits = search_proteins(query) st.multiselect( f"Top {len(hits)} matches" if len(hits) == SEARCH_LIMIT else f"Matches ({len(hits)})", options=hits, key="search_pick", format_func=lambda p: f"{p} — {names.get(p, '')}", placeholder="Pick one or more matches", ) st.button("Add selected", on_click=add_from_search, key="add_search", disabled=not st.session_state.get("search_pick")) else: st.caption("Type at least 3 characters.") with upload_tab: st.file_uploader("Text file with one UniProt ID per line", type=["txt", "csv", "tsv"], key="upload_file") st.button("Add from file", on_click=add_from_file, key="add_file", disabled=st.session_state.get("upload_file") is None) with example_tab: st.markdown('Load five random proteins from the knowledge graph ' "to see how ProtHGT works.", unsafe_allow_html=True) st.button("Load example proteins", on_click=add_example, key="add_example") notice = st.session_state.notice if notice: parts = [] if notice["added"]: parts.append(f"Added {notice['added']} protein{'s' if notice['added'] != 1 else ''} " f"from {notice['source']}.") if notice["duplicates"]: parts.append(f"{notice['duplicates']} already in your list.") if parts: st.success(" ".join(parts)) elif not notice["unknown"]: st.info("No UniProt IDs found in the input.") if notice["unknown"]: st.warning( f"{len(notice['unknown'])} ID(s) are not in the ProtHGT knowledge graph and were skipped. " "Predictions for proteins outside the graph are not supported yet." ) with st.expander("Show skipped IDs"): st.code("\n".join(notice["unknown"]), language=None) if notice["over_limit"]: st.error(f"{len(notice['over_limit'])} protein(s) were not added: the limit is " f"{MAX_PROTEINS} per run.") st.divider() st.multiselect( f"Selected proteins ({len(st.session_state.proteins)}/{MAX_PROTEINS})", options=st.session_state.proteins, key="proteins", placeholder="Add proteins using one of the tabs above", help="Click × on a protein to remove it.", ) if st.session_state.proteins: c1, c2, _ = st.columns([1, 1, 2]) c1.download_button("Download list", "\n".join(st.session_state.proteins), file_name="selected_proteins.txt", mime="text/plain") c2.button("Clear all", on_click=clear_proteins) _, nav = st.columns([3, 1.3]) nav.button("Continue →", type="primary", use_container_width=True, disabled=not st.session_state.proteins, on_click=go_to, args=(2,)) with aside: render_limit_aside() # --------------------------------------------------------------------------- # Step 2 — choose what to predict # --------------------------------------------------------------------------- def render_step_2(): if not st.session_state.proteins: go_to(1) st.rerun() main, aside = st.columns([2.3, 1], gap="large") with main: with st.container(border=True): st.subheader("Which functions are you interested in?") # 2x2 grid: the three GO aspects plus EC numbers. Fixed-height cards so # every box is the same size regardless of how much text it holds. items = [(f"aspect_{k}", "Gene Ontology", label, desc) for k, (label, desc) in ASPECTS.items()] items.append(( "predict_ec", "Enzyme Commission", "EC number", "EC numbers for enzymes, predicted across the four hierarchy levels (L1–L4) as a " "consistent top-down chain. Non-enzymes return no EC number.", )) for i in range(0, len(items), 2): cols = st.columns(2) for col, (key, eyebrow, title, desc) in zip(cols, items[i:i + 2]): with col: with st.container(border=True, height=158): st.markdown(f'{eyebrow}', unsafe_allow_html=True) st.checkbox(f"**{title}**", key=key) st.caption(desc) st.subheader("How strict should predictions be?") st.radio( "Prediction strictness", options=list(STRICTNESS), key="strictness", horizontal=True, label_visibility="collapsed", captions=[f"{d} · score ≥ {t:.2f}" for t, d in STRICTNESS.values()], disabled=st.session_state.use_custom_threshold, ) with st.expander("Advanced: set a custom score threshold", expanded=st.session_state.use_custom_threshold): st.checkbox("Use a custom threshold", key="use_custom_threshold") st.slider("Minimum score", 0.0, 1.0, step=0.05, key="custom_threshold", disabled=not st.session_state.use_custom_threshold, help="Only GO terms scoring at or above this value are returned. " "Lower values return many more terms and take longer.") if st.session_state.use_custom_threshold and st.session_state.custom_threshold < 0.1: st.caption("A very low threshold returns almost every GO term for each protein; " "expect a large table.") anything = selected_aspects() or st.session_state.predict_ec back, _, run = st.columns([1, 1.7, 1.3]) back.button("← Back", use_container_width=True, on_click=go_to, args=(1,)) run.button("Run prediction →", type="primary", use_container_width=True, disabled=not anything, on_click=go_to, args=(3,)) if not anything: st.caption("Select at least one function category or EC numbers.") with aside: render_limit_aside() # --------------------------------------------------------------------------- # Step 3 — run & review # --------------------------------------------------------------------------- def run_go_prediction(proteins, aspects, threshold): with st.status("Running ProtHGT (GO terms)…", expanded=True) as status: if os.path.exists(KG_PATH): st.write("Loading the knowledge graph…") else: st.write("Downloading dataset files for the first time, this may take a few minutes…") heterodata = get_kg() progress = st.progress(0.0) def on_category(i, n, go_cat): progress.progress(i / n, text=f"Scoring {ASPECTS[go_cat][0].lower()} terms ({i + 1}/{n})") models = {cat: get_model(cat) for cat in aspects} _, df = generate_prediction_df( protein_ids=proteins, go_category=aspects, threshold=threshold, heterodata=heterodata, models=models, progress_callback=on_category, ) progress.progress(1.0, text="Done") status.update(label=f"Predicted {len(df):,} protein–GO term associations", state="complete", expanded=False) return df.sort_values("Probability", ascending=False, ignore_index=True) def run_ec_prediction(proteins, threshold): with st.status("Running ProtHGT (EC numbers)…", expanded=True) as status: if os.path.exists(EC_KG_PATH): st.write("Loading the EC knowledge graph…") else: st.write("Downloading EC dataset files for the first time, this may take a few minutes…") heterodata = get_ec_kg() model = get_ec_model() progress = st.progress(0.0) def on_protein(i, n): progress.progress(i / n, text=f"Scoring EC numbers ({i + 1}/{n})") _, df = generate_ec_prediction_df( proteins, heterodata, model, threshold=threshold, progress_callback=on_protein) progress.progress(1.0, text="Done") status.update(label=f"Predicted {len(df):,} protein–EC number associations", state="complete", expanded=False) return df.sort_values("Probability", ascending=False, ignore_index=True) @st.fragment def render_predictions(df, threshold): if df.empty: st.info("No GO terms passed the score threshold. Try a lower strictness in step 2.") return f1, f2, f3 = st.columns([1.2, 1.2, 1.6]) proteins = ["All proteins"] + sorted(df["UniProt_ID"].unique()) protein = f1.selectbox("Protein", proteins, format_func=lambda p: p if p == "All proteins" else f"{p} — {df.loc[df.UniProt_ID == p, 'Protein'].iat[0]}") available = [c for c in CATEGORY_TO_KEY if c in set(df["GO_category"])] aspects = f2.pills("Aspect", available, selection_mode="multi", default=available, format_func=lambda c: ASPECT_SHORT[CATEGORY_TO_KEY[c]]) text = f3.text_input("Search GO ID or term", placeholder="e.g. GO:0005524 or binding") min_score = st.slider("Minimum score", float(threshold), 1.0, float(threshold), step=0.01) view = df if protein != "All proteins": view = view[view["UniProt_ID"] == protein] view = view[view["GO_category"].isin(aspects or [])] if text.strip(): t = text.strip() view = view[view["GO_ID"].str.contains(t, case=False, regex=False) | view["GO_term"].str.contains(t, case=False, regex=False)] view = view[view["Probability"] >= min_score] display = view.assign( UniProt_ID="https://www.uniprot.org/uniprotkb/" + view["UniProt_ID"] + "/entry", GO_ID="https://www.ebi.ac.uk/QuickGO/term/" + view["GO_ID"], GO_category=view["GO_category"].map(lambda c: ASPECT_SHORT[CATEGORY_TO_KEY[c]]), # MF/BP/CC; CSV keeps full names ) # Fixed widths for the long text columns so the table fits the page instead of scrolling sideways; # truncated cells show their full text on hover. Short columns keep their automatic width. st.dataframe( display, hide_index=True, use_container_width=True, height=520, column_config={ "UniProt_ID": st.column_config.LinkColumn("UniProt ID", display_text=r"uniprotkb/([A-Z0-9]+)/entry"), "Protein": st.column_config.TextColumn("Protein", width="large"), "GO_ID": st.column_config.LinkColumn("GO ID", display_text=r"term/(GO:[0-9]+)"), "GO_term": st.column_config.TextColumn("GO term", width="medium"), "GO_category": st.column_config.TextColumn( "Aspect", help="MF: molecular function · BP: biological process · CC: cellular component"), # Plain number: scores cluster near 1, so a bar adds little; 3 decimals keep close scores apart "Probability": st.column_config.NumberColumn("Score", format="%.3f", width="small"), }, ) st.caption(f"Showing {len(view):,} of {len(df):,} predictions") def _expasy_url(ec): """ExPASy ENZYME URL for an EC number or class prefix (padded to four fields with '-').""" parts = ec.split(".") parts += ["-"] * (4 - len(parts)) return "https://enzyme.expasy.org/EC/" + ".".join(parts) @st.fragment def render_ec_predictions(df, threshold): if df.empty: st.info("No EC numbers passed the score threshold — none of these proteins were predicted as " "enzymes at this strictness. Try a lower strictness in step 2.") return f1, f2, f3 = st.columns([1.2, 1.2, 1.6]) proteins = ["All proteins"] + sorted(df["UniProt_ID"].unique()) protein = f1.selectbox("Protein", proteins, key="ec_protein", format_func=lambda p: p if p == "All proteins" else f"{p} — {df.loc[df.UniProt_ID == p, 'Protein'].iat[0]}") all_levels = ["L1", "L2", "L3", "L4"] available = [lv for lv in all_levels if lv in set(df["EC_level"])] levels = f2.pills("Level", available, selection_mode="multi", default=available, key="ec_levels") text = f3.text_input("Search EC number", placeholder="e.g. 2.7.11", key="ec_search") min_score = st.slider("Minimum score", float(threshold), 1.0, float(threshold), step=0.01, key="ec_min") view = df if protein != "All proteins": view = view[view["UniProt_ID"] == protein] view = view[view["EC_level"].isin(levels or [])] if text.strip(): view = view[view["EC"].str.contains(text.strip(), case=False, regex=False)] view = view[view["Probability"] >= min_score] display = view.assign( UniProt_ID="https://www.uniprot.org/uniprotkb/" + view["UniProt_ID"] + "/entry", EC=view["EC"].map(_expasy_url), ) st.dataframe( display, hide_index=True, use_container_width=True, height=520, column_config={ "UniProt_ID": st.column_config.LinkColumn("UniProt ID", width="small", display_text=r"uniprotkb/([A-Z0-9]+)/entry"), "Protein": st.column_config.TextColumn("Protein", width="medium"), "EC": st.column_config.LinkColumn("EC number", width="small", display_text=r"EC/([\d.]*\d)", help="L1 (class) → L4 (full EC number). Opens the ExPASy ENZYME entry."), "EC_name": st.column_config.TextColumn("Name", width="large", help="Enzyme class (L1–L3) or enzyme name (L4)."), "EC_level": st.column_config.TextColumn("Level", width="small"), "Probability": st.column_config.NumberColumn("Score", format="%.3f", width="small"), }, ) st.caption("Predictions form a consistent hierarchy: every predicted L4 number has its predicted " "L3/L2/L1 ancestors. A protein can stop at an intermediate level when no deeper level " "passes the threshold.") st.caption(f"Showing {len(view):,} of {len(df):,} predictions") @st.fragment def render_knowledge_graph(df_go, df_ec, proteins, aspects): if len(proteins) > MAX_KG_VIZ_PROTEINS: st.info(f"Knowledge graph views are available for runs of up to {MAX_KG_VIZ_PROTEINS} proteins.") return go_ok = df_go is not None ec_ok = df_ec is not None st.markdown('Explore the biological relationships around a protein that ' "the model draws on: GO annotations, EC numbers, domains, interactions, pathways and more. " "Views go up to second-degree connections; for deeper exploration, " f'download the complete knowledge graph.', unsafe_allow_html=True) with st.expander("How to read this graph"): st.markdown(KG_VIEW_GUIDE) # Which predictions to overlay on the graph (only when both types were run). if go_ok and ec_ok: overlays = st.pills("Predictions to show on the graph", ["GO terms", "EC numbers"], selection_mode="multi", default=["GO terms", "EC numbers"], key="viz_overlays") else: overlays = (["GO terms"] if go_ok else []) + (["EC numbers"] if ec_ok else []) show_go = "GO terms" in overlays show_ec = "EC numbers" in overlays # General graph settings (apply to every node type). g1, g2, g3 = st.columns([1.6, 1, 1]) protein = g1.selectbox("Protein", proteins, key="viz_protein") limit = g2.slider( "Neighbours per edge type", 5, 50, 10, step=5, help="Maximum direct neighbours shown for each relationship type (domains, interactions, " "pathways, …), including known annotations outside the top predictions.") second_limit = g3.slider( "Second-degree neighbours", 0, 10, 0, help="Neighbours of the protein's direct neighbours, e.g. other proteins sharing a domain or " "pathway with it. 0 shows direct neighbours only; higher values quickly make the graph dense. " "Does not affect the EC hierarchy, which is always drawn in full.") include_second = second_limit > 0 # Prediction-type-specific settings (only for the overlays being shown). pred_limit, ec_top1 = 5, False if show_go or show_ec: boxes = st.columns(2) if (show_go and show_ec) else [st.container()] bi = 0 box_h = 150 # equal height so the GO (slider) and EC (checkbox) cards line up if show_go: with boxes[bi]: with st.container(border=True, height=box_h): st.markdown("**GO term predictions**") pred_limit = st.slider( "Top terms shown per category", 1, 20, 5, key="go_pred_limit", help="Highest-scoring GO predictions per category. Purple: also annotated in the " "knowledge graph; red: novel.") bi += 1 if show_ec: with boxes[bi]: with st.container(border=True, height=box_h): st.markdown("**EC number predictions**") ec_top1 = st.checkbox( "Best prediction per level only", key="ec_top1", help="Show only the single highest-scoring EC at each hierarchy level (one clean " "chain) instead of every EC above the threshold.") st.caption("Otherwise every EC scoring above the threshold is shown.") # The EC knowledge graph is a superset (GO context + EC hierarchy), so it serves both overlays; # use the GO graph only when EC was not predicted. kg = get_ec_kg() if ec_ok else get_kg() viz_key = f"{protein}|{pred_limit}|{limit}|{second_limit}|{show_go}|{show_ec}|{ec_top1}" viz = st.session_state.viz.get(viz_key) if viz is None: disabled = not (show_go or show_ec) if st.button("Show graph", type="primary", key="viz_go", disabled=disabled): with st.spinner("Building subgraph…"): path, edges = visualize_protein_subgraph( kg, protein, go_df=df_go, ec_df=df_ec, show_go=show_go, show_ec=show_ec, limit=limit, prediction_limit=pred_limit, predicted_categories=aspects, second_degree_limit=second_limit, include_second_degree=include_second, ec_top1=ec_top1) st.session_state.viz[viz_key] = {"path": path, "edges": edges} st.rerun(scope="fragment") if disabled: st.caption("Select at least one prediction type to overlay.") return with open(viz["path"], "r", encoding="utf-8") as f: # 760px graph with both legends inside it; PNG and edges-JSON downloads are in its toolbox # (kg_graph_template.html) st.components.v1.html(f.read(), height=775, scrolling=True) def render_step_3(): proteins = list(st.session_state.proteins) aspects = selected_aspects() predict_ec = st.session_state.predict_ec if not proteins or not (aspects or predict_ec): go_to(1 if not proteins else 2) st.rerun() threshold = current_threshold() run_key = (tuple(proteins), tuple(aspects), predict_ec, threshold) results = st.session_state.results if results is None or results["key"] != run_key: clear_visualizations() cache = st.session_state.results_cache if run_key in cache: # switching back to settings already run in this session is instant payload = cache[run_key] else: try: df_go = run_go_prediction(proteins, aspects, threshold) if aspects else None df_ec = run_ec_prediction(proteins, threshold) if predict_ec else None except Exception as exc: # surface failures instead of a blank page st.error(f"Prediction failed: {exc}") st.button("← Back to settings", on_click=go_to, args=(2,)) return payload = {"go": df_go, "ec": df_ec} cache[run_key] = payload while len(cache) > 3: # keep memory per visitor bounded cache.pop(next(iter(cache))) st.session_state.results = {"key": run_key, "payload": payload} results = st.session_state.results payload = results["payload"] df_go, df_ec = payload["go"], payload["ec"] head, b1, b2 = st.columns([3, 1.1, 1.1], vertical_alignment="bottom") head.subheader("Results") b1.button("Change settings", on_click=go_to, args=(2,), use_container_width=True) b2.button("New prediction", on_click=start_new_prediction, use_container_width=True) m1, m2, m3, m4 = st.columns(4) m1.metric("Proteins", len(proteins)) m2.metric("Predicted GO terms", f"{len(df_go):,}" if df_go is not None else "—") m3.metric("Predicted EC numbers", f"{len(df_ec):,}" if df_ec is not None else "—") m4.metric("Score threshold", f"{threshold:.2f}") tab_specs = [] if aspects: tab_specs.append(("GO terms", lambda: render_predictions(df_go, threshold))) if predict_ec: tab_specs.append(("EC numbers", lambda: render_ec_predictions(df_ec, threshold))) if aspects or predict_ec: tab_specs.append(("Knowledge graph", lambda: render_knowledge_graph(df_go, df_ec, proteins, aspects))) for tab, (_, render) in zip(st.tabs([label for label, _ in tab_specs]), tab_specs): with tab: render() # Render the step inside one st.empty() slot so the previous step's widgets are replaced # immediately instead of lingering (greyed out) while a long prediction runs. with st.empty().container(): {1: render_step_1, 2: render_step_2, 3: render_step_3}[step]()