Sync from GitHub (preserve manual model files)

.gitignore

@@ -3,5 +3,8 @@ Data/**/*.tmp
 Data/**/*.log
 MLModels/**/*.pt
 MLModels/**/*.pth
-StreamlitApp/utils/__pycache__/
+# Python bytecode (safe to ignore everywhere)
+__pycache__/
+*.py[cod]
+*$py.class
 StreamlitApp/models/*.pt

StreamlitApp/StreamlitApp.py

@@ -27,9 +27,9 @@ from utils.ui_helpers import (
 from utils.peptide_extras import (
     KNOWN_AMPS,
     MAX_3D_SEQUENCE_LENGTH,
-    HELIX_WHEEL_LEGEND_MARKDOWN,
-    STRUCTURE_3D_INTERPRETATION_MARKDOWN,
-    STRUCTURE_3D_LEGEND_MARKDOWN,
+    COMPACT_3D_LEGEND,
+    COMPACT_MAP_LEGEND,
+    COMPACT_WHEEL_LEGEND,
     find_most_similar,
     build_importance_map_html,
     plot_helical_wheel,
@@ -405,7 +405,7 @@ elif page == "Analyze":
             "left:50%;"
             "top:125%;"
             "transform:translateX(-50%);"
-            "max-width:320px;"
+            "max-width:560px;"
             "white-space:normal;"
             "padding:8px 10px;"
             "background:rgba(30,30,30,0.95);"
@@ -558,24 +558,6 @@ elif page == "Optimize":
                 f"Hydrophobicity: **{summary['hydro_change']}** (orig {summary['hydro_orig']}, final {summary['hydro_final']})"
             )
 
-        if improved_seq and str(improved_seq).strip():
-            st.divider()
-            st.subheader("Optimized Structure Visualization")
-            st.caption(
-                "Helix-like CA trace approximation for the optimized sequence (not an experimental fold)."
-            )
-            opt_clean = "".join(c for c in str(improved_seq).upper() if not c.isspace())
-            if len(opt_clean) > MAX_3D_SEQUENCE_LENGTH:
-                st.warning("Sequence too long for 3D visualization (max 60 residues).")
-            elif render_3d_structure(improved_seq, enhanced=False):
-                with st.expander("Visualization info", expanded=False):
-                    st.markdown(STRUCTURE_3D_LEGEND_MARKDOWN)
-                    st.markdown(STRUCTURE_3D_INTERPRETATION_MARKDOWN)
-            else:
-                st.info(
-                    "3D view unavailable (install **py3dmol** in your environment, or try again after redeploy)."
-                )
-
         st.divider()
         # Mutation Heatmap
         st.subheader("Mutation Heatmap (Changed Residues Highlighted)")
@@ -607,6 +589,23 @@ elif page == "Optimize":
 #  VISUALIZE PEPTIDE PAGE
 elif page == "Visualize Peptide":
     st.header("Visualize Peptide")
+    # Tighter legend expanders (summary row + scrollable body)
+    st.markdown(
+        """
+        <style>
+        div[data-testid="stExpander"] details > summary {
+            padding-top: 0.3rem !important;
+            padding-bottom: 0.3rem !important;
+            min-height: 2rem !important;
+        }
+        div[data-testid="stExpander"] details div[data-testid="stMarkdownContainer"] {
+            max-height: 6.5rem;
+            overflow-y: auto;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True,
+    )
     st.caption(
         "High-impact single-sequence view. **Blue / red / green / gray** match the 3D model, helical wheel, "
         "and functional residue map."
@@ -617,28 +616,20 @@ elif page == "Visualize Peptide":
         if sug:
             st.session_state.visualize_peptide_input = sug
 
-    c_btn, c_auto = st.columns([2, 1])
-    with c_btn:
-        if st.button("Use suggested sequence (Predict / Analyze / Optimize)", key="btn_viz_peptide_prefill"):
-            st.session_state.visualize_peptide_input = _prefill_peptide_viz_sequence()
-            rerun_fn = getattr(st, "rerun", None) or getattr(st, "experimental_rerun", None)
-            if rerun_fn:
-                rerun_fn()
-    with c_auto:
-        st.checkbox("Auto-run when sequence changes", value=False, key="viz_peptide_auto_run")
+    st.checkbox("Auto-run when sequence changes", value=False, key="viz_peptide_auto_run")
 
     st.text_input(
         "Peptide sequence",
         key="visualize_peptide_input",
         placeholder="One-letter amino-acid sequence",
-        help="Empty field picks up your last optimized, analyzed, or predicted sequence when you open this page.",
+        help="When empty, your last optimized / analyzed / predicted sequence is filled in automatically.",
     )
 
     seq_viz = (st.session_state.get("visualize_peptide_input") or "").strip()
     clean_viz = "".join(c for c in seq_viz.upper() if not c.isspace())
     if not clean_viz:
         st.session_state.viz_peptide_last_computed = ""
-        st.info("Enter a sequence above, or click **Use suggested sequence** to pull from other tools.")
+        st.info("Enter a sequence above (or navigate from Predict / Analyze / Optimize to auto-fill when empty).")
     else:
         run_viz = st.button("Run visualization", type="primary", key="viz_peptide_run_btn")
         auto_on = bool(st.session_state.get("viz_peptide_auto_run"))
@@ -666,12 +657,11 @@ elif page == "Visualize Peptide":
             col_l, col_r = st.columns(2)
             with col_l:
                 st.subheader("3D structural approximation (py3Dmol)")
-                st.caption("Smoothed helical CA trace; colored spheres follow the same scheme as the wheel below.")
+                st.caption("Smoothed helical CA trace; colored spheres follow the same scheme as the wheel.")
                 if len(clean_viz) <= MAX_3D_SEQUENCE_LENGTH:
-                    if render_3d_structure(clean_viz, enhanced=True):
-                        with st.expander("Legend & interpretation (3D)", expanded=False):
-                            st.markdown(STRUCTURE_3D_LEGEND_MARKDOWN)
-                            st.markdown(STRUCTURE_3D_INTERPRETATION_MARKDOWN)
+                    if render_3d_structure(clean_viz, enhanced=True, spin=False):
+                        with st.expander("3D · legend", expanded=False):
+                            st.markdown(COMPACT_3D_LEGEND)
                     else:
                         st.info("3D view unavailable (install **py3dmol** in your environment).")
                 else:
@@ -683,31 +673,32 @@ elif page == "Visualize Peptide":
                 fig_wheel = plot_helical_wheel(clean_viz)
                 st.pyplot(fig_wheel, use_container_width=True)
                 plt.close(fig_wheel)
-                with st.expander("Helical wheel legend", expanded=False):
-                    st.markdown(HELIX_WHEEL_LEGEND_MARKDOWN)
-
-                st.subheader("Functional region map")
-                st.caption("Residue-level chemistry; colors align with the 3D view and wheel.")
-                st.markdown(build_importance_map_html(clean_viz), unsafe_allow_html=True)
-                with st.expander("Color key (sequence map)", expanded=False):
-                    st.markdown(STRUCTURE_3D_LEGEND_MARKDOWN)
-
-                st.subheader("Most similar known AMP")
-                st.caption(
-                    f"Compared to **{len(KNOWN_AMPS)}** unique AMP sequences (label = 1 in `Data/ampData.csv`)."
-                )
-                match_seq, sim_score = find_most_similar(clean_viz)
-                if match_seq is not None:
-                    st.write(f"**Best match:** `{match_seq}`")
-                    st.write(f"**Similarity score:** **{sim_score:.3f}** (position match / max length)")
-                    if sim_score > 0.6:
-                        st.success("High similarity to a known AMP in the reference set.")
-                    elif sim_score > 0.3:
-                        st.warning("Moderate similarity — interpret with care.")
-                    else:
-                        st.error("Low similarity — sequence is distant from reference AMPs.")
+                with st.expander("Wheel · legend", expanded=False):
+                    st.markdown(COMPACT_WHEEL_LEGEND)
+
+            st.divider()
+            st.subheader("Functional region map")
+            st.caption("Residue-level chemistry; colors align with the 3D view and wheel.")
+            st.markdown(build_importance_map_html(clean_viz), unsafe_allow_html=True)
+            with st.expander("Map · legend", expanded=False):
+                st.markdown(COMPACT_MAP_LEGEND)
+
+            st.subheader("Most similar known AMP")
+            st.caption(
+                f"Compared to **{len(KNOWN_AMPS)}** unique AMP sequences (label = 1 in `Data/ampData.csv`)."
+            )
+            match_seq, sim_score = find_most_similar(clean_viz)
+            if match_seq is not None:
+                st.write(f"**Best match:** `{match_seq}`")
+                st.write(f"**Similarity score:** **{sim_score:.3f}** (position match / max length)")
+                if sim_score > 0.6:
+                    st.success("High similarity to a known AMP in the reference set.")
+                elif sim_score > 0.3:
+                    st.warning("Moderate similarity — interpret with care.")
                 else:
-                    st.warning("Could not compute similarity (empty sequence after cleaning).")
+                    st.error("Low similarity — sequence is distant from reference AMPs.")
+            else:
+                st.warning("Could not compute similarity (empty sequence after cleaning).")
 
         elif clean_viz != (st.session_state.get("viz_peptide_last_computed") or ""):
             st.caption("Click **Run visualization** or enable **Auto-run** to update the figures.")
@@ -816,7 +807,7 @@ PeptideAI is a lightweight Streamlit app for exploring antimicrobial peptide (AM
 It uses a trained neural network to estimate whether a peptide is likely to be antimicrobial, then helps you interpret and improve candidates:
 - **Predict**: batch predictions from multi-line or FASTA input, length warnings, persisted results, top-candidate highlight, and CSV export.
 - **Analyze**: single-sequence numerical & textual analysis — AMP prediction, composition, physicochemical table + radar, and exportable report (no 3D on this page).
-- **Optimize**: guided sequence optimization with mutation heatmap, step table, confidence vs. step plot, and an optional 3D view of the optimized sequence.
+- **Optimize**: guided sequence optimization with mutation heatmap, step table, and confidence vs. step plot.
 - **Visualize Peptide**: one sequence with consistent coloring across functional map, helical wheel, and optional 3D approximation, plus similarity to known AMPs.
 - **Visualize t-SNE**: upload many sequences, embed with the model, run t-SNE, and explore clusters with filters and hover metadata.
 - **About**: this overview and disclaimer.

StreamlitApp/utils/peptide_extras.py

@@ -172,38 +172,58 @@ HELIX_WHEEL_LEGEND_MARKDOWN: str = """
 Residues are placed using a **100° step** per position (common α-helical wheel convention). This is a **2D projection**, not a solved 3D structure.
 """
 
+# Short blurbs for compact UI expanders (Visualize Peptide page)
+COMPACT_3D_LEGEND: str = (
+    "**Blue** K,R,H · **Red** D,E · **Green** hydrophobic (AVLIMFWY) · **Gray** other. "
+    "Helix trace is an approximation, not an experimental structure."
+)
+COMPACT_WHEEL_LEGEND: str = (
+    "**100°** per residue. Cationic (blue) and hydrophobic (green) faces often matter for membrane-active helices."
+)
+COMPACT_MAP_LEGEND: str = (
+    "Same scheme as 3D and wheel: charged vs hydrophobic distribution along the sequence."
+)
+
 
 def plot_helical_wheel(sequence: str, figsize: Tuple[float, float] = (6.2, 6.2)) -> Any:
     """
     Amphipathic-style helical wheel (matplotlib polar). Colors match 3D / HTML maps.
+    Uses dark text for contrast on all wedge colors (avoids white-on-light issues in Streamlit).
     """
     import matplotlib.pyplot as plt
+    from matplotlib import patheffects as pe
 
     clean = "".join(c for c in (sequence or "").upper() if not c.isspace())
     n = len(clean)
     fig, ax = plt.subplots(figsize=figsize, subplot_kw={"projection": "polar"})
+    fig.patch.set_facecolor("white")
     if n == 0:
+        ax.set_facecolor("#f5f5f5")
         ax.set_title("Helical wheel (empty sequence)", pad=12)
         return fig
 
+    ax.set_facecolor("#f5f5f5")
+
     angles_deg = np.array([i * 100.0 for i in range(n)], dtype=float) % 360.0
     angles_rad = np.deg2rad(angles_deg)
     width = np.deg2rad(min(360.0 / max(n, 1) * 0.92, 0.45))
     r0, r1 = 0.35, 1.0
+    fs = max(7, min(12, int(240 / max(n, 1))))
     for i, aa in enumerate(clean):
         th = angles_rad[i]
         color = residue_color_mpl(aa)
-        ax.bar(th, r1 - r0, width=width, bottom=r0, color=color, edgecolor="black", linewidth=0.35, align="center")
-        ax.text(
+        ax.bar(th, r1 - r0, width=width, bottom=r0, color=color, edgecolor="#222222", linewidth=0.5, align="center")
+        t = ax.text(
             th,
             (r0 + r1) / 2.0,
             aa,
             ha="center",
             va="center",
-            fontsize=max(6, min(11, int(220 / max(n, 1)))),
-            color="white",
+            fontsize=fs,
+            color="#111111",
             fontweight="bold",
         )
+        t.set_path_effects([pe.withStroke(linewidth=2.5, foreground="white")])
 
     ax.set_theta_zero_location("N")
     ax.set_theta_direction(-1)
@@ -211,8 +231,7 @@ def plot_helical_wheel(sequence: str, figsize: Tuple[float, float] = (6.2, 6.2))
     ax.set_yticklabels([])
     ax.set_xticklabels([])
     ax.grid(False)
-    ax.set_title("Helical wheel (α-helix projection, approximate)", pad=14, fontsize=11)
-    fig.patch.set_facecolor("white")
+    ax.set_title("Helical wheel (α-helix projection, approximate)", pad=14, fontsize=11, color="#111111")
     return fig
 
 
@@ -299,10 +318,12 @@ def render_3d_structure(
     iframe_height: int = 420,
     *,
     enhanced: bool = False,
+    spin: bool = False,
 ) -> bool:
     """
     Render py3Dmol view: gray stick backbone + colored spheres per residue (CA-only PDB).
-    When enhanced=True: smoother helix path, slightly larger spheres, optional spin, more labels.
+    When enhanced=True: smoother helix path, slightly larger spheres, more labels.
+    When spin=True: enable viewer spin (off by default).
     Not a real folded structure — helix-like CA trace only.
     """
     import streamlit.components.v1 as components
@@ -373,7 +394,7 @@ def render_3d_structure(
 
         view.zoomTo()
 
-        if enhanced:
+        if spin:
             try:
                 view.spin(True)
             except Exception: