Sync from GitHub (preserve manual model files)

StreamlitApp/StreamlitApp.py

@@ -24,6 +24,11 @@ from utils.ui_helpers import (
     sequence_health_label,
     build_analysis_summary_text,
 )
+from utils.peptide_extras import (
+    find_most_similar,
+    build_importance_map_html,
+    render_3d_structure,
+)
 
 try:
     import pyperclip  # Optional; may not exist in all environments.
@@ -401,6 +406,36 @@ elif page == "Analyze":
         ax.legend(loc='lower center', bbox_to_anchor=(0.85, 1.15), ncol=2, fontsize=7)
         st.pyplot(fig, use_container_width=False)
 
+        st.divider()
+        sequence = st.session_state.analyze_input or ""
+        if sequence.strip():
+            st.subheader("Functional Region Highlighting")
+            st.caption(
+                "Highlighted regions indicate residues likely contributing to antimicrobial activity"
+            )
+            st.markdown(build_importance_map_html(sequence), unsafe_allow_html=True)
+
+            st.subheader("Most Similar Known AMP")
+            match_seq, sim_score = find_most_similar(sequence)
+            if match_seq is not None:
+                st.write(f"Sequence: **{match_seq}**")
+                st.write(f"Similarity Score: **{sim_score:.2f}**")
+                if sim_score > 0.6:
+                    st.success("High similarity to known AMP")
+                elif sim_score > 0.3:
+                    st.warning("Moderate similarity")
+                else:
+                    st.error("Low similarity")
+
+            st.subheader("3D Structural Approximation")
+            st.caption(
+                "This is a structural approximation to visualize residue distribution (not an experimental structure)."
+            )
+            if not render_3d_structure(sequence):
+                st.info(
+                    "3D view unavailable (install **py3dmol** in your environment, or try again after redeploy)."
+                )
+
         st.divider()
         # Analysis Summary
         st.subheader("Analysis Summary")
@@ -481,6 +516,17 @@ elif page == "Optimize":
             f"**Optimized Sequence:** {improved_seq} — Confidence: {round(improved_conf*100,1)}%"
         )
 
+        if improved_seq and str(improved_seq).strip():
+            st.divider()
+            st.subheader("3D Structural Approximation (optimized sequence)")
+            st.caption(
+                "Helix-like CA trace approximation for the optimized sequence (not an experimental structure)."
+            )
+            if not render_3d_structure(improved_seq):
+                st.info(
+                    "3D view unavailable (install **py3dmol** in your environment, or try again after redeploy)."
+                )
+
         # Optimization Summary box
         summary = optimization_summary(orig_seq, orig_conf, improved_seq, improved_conf)
         delta_str = f"{summary['delta_conf_pct']:+.2f}%"

StreamlitApp/utils/peptide_extras.py

@@ -0,0 +1,156 @@
+"""
+Optional peptide UI helpers: 3D approximation (py3Dmol), known-AMP similarity, residue highlighting.
+
+Does not modify model loading or prediction logic.
+"""
+from __future__ import annotations
+
+import math
+from typing import List, Optional, Tuple
+
+# Small reference set of known AMP sequences (for similarity display only).
+KNOWN_AMPS: List[str] = [
+    "KWKLFKKIGAVLKVL",
+    "GIGKFLHSAKKFGKAFVGEIMNS",
+    "LLGDFFRKSKEKIGKEFKRIVQRIKDFLRNLV",
+    "KLFKKILKYL",
+    "FLPLLAGLAANFLPKIFCKITRKC",
+]
+
+# One-letter -> three-letter (for minimal PDB lines for py3Dmol).
+_ONE_TO_THREE = {
+    "A": "ALA",
+    "R": "ARG",
+    "N": "ASN",
+    "D": "ASP",
+    "C": "CYS",
+    "Q": "GLN",
+    "E": "GLU",
+    "G": "GLY",
+    "H": "HIS",
+    "I": "ILE",
+    "L": "LEU",
+    "K": "LYS",
+    "M": "MET",
+    "F": "PHE",
+    "P": "PRO",
+    "S": "SER",
+    "T": "THR",
+    "W": "TRP",
+    "Y": "TYR",
+    "V": "VAL",
+}
+
+
+def sequence_similarity(seq1: str, seq2: str) -> float:
+    """Position-wise match rate normalized by max length (as specified)."""
+    if not seq1 or not seq2:
+        return 0.0
+    matches = sum(1 for a, b in zip(seq1, seq2) if a == b)
+    return matches / max(len(seq1), len(seq2))
+
+
+def find_most_similar(sequence: str) -> Tuple[Optional[str], float]:
+    if not sequence or not KNOWN_AMPS:
+        return None, 0.0
+    best_seq = KNOWN_AMPS[0]
+    best_score = sequence_similarity(sequence, KNOWN_AMPS[0])
+    for amp in KNOWN_AMPS[1:]:
+        score = sequence_similarity(sequence, amp)
+        if score > best_score:
+            best_score = score
+            best_seq = amp
+    return best_seq, best_score
+
+
+def get_residue_color(aa: str) -> str:
+    positive = ["K", "R", "H"]
+    negative = ["D", "E"]
+    hydrophobic = ["A", "V", "I", "L", "M", "F", "W", "Y"]
+    if aa in positive:
+        return "blue"
+    if aa in negative:
+        return "red"
+    if aa in hydrophobic:
+        return "green"
+    return "gray"
+
+
+def get_residue_style(aa: str) -> str:
+    positive = ["K", "R", "H"]
+    negative = ["D", "E"]
+    hydrophobic = ["A", "V", "I", "L", "M", "F", "W", "Y"]
+    if aa in positive:
+        return "background-color: blue; color: white; padding: 2px;"
+    if aa in negative:
+        return "background-color: red; color: white; padding: 2px;"
+    if aa in hydrophobic:
+        return "background-color: green; color: white; padding: 2px;"
+    return "background-color: lightgray; padding: 2px;"
+
+
+def build_importance_map_html(sequence: str) -> str:
+    """Build HTML for residue importance highlighting (escape non-AA safely)."""
+    import html as html_mod
+
+    parts: List[str] = []
+    for ch in sequence:
+        if ch.isspace():
+            continue
+        aa = ch.upper()
+        style = get_residue_style(aa)
+        parts.append(f'<span style="{style}">{html_mod.escape(aa)}</span>')
+    return "".join(parts)
+
+
+def generate_helix_pdb(sequence: str) -> str:
+    """Generate a minimal PDB string (helix-like CA trace) for visualization."""
+    pdb_lines: List[str] = []
+    atom_index = 1
+    clean = "".join(c for c in sequence.upper() if not c.isspace())
+    for i, aa in enumerate(clean):
+        res_name = _ONE_TO_THREE.get(aa, "UNK")
+        angle = i * 100 * (math.pi / 180.0)
+        x = math.cos(angle) * 5.0
+        y = math.sin(angle) * 5.0
+        z = i * 1.5
+        res_num = i + 1
+        pdb_lines.append(
+            f"ATOM  {atom_index:5d}  CA  {res_name:3s} A{res_num:4d}    "
+            f"{x:8.3f}{y:8.3f}{z:8.3f}  1.00  0.00           C"
+        )
+        atom_index += 1
+    return "\n".join(pdb_lines)
+
+
+def render_3d_structure(sequence: str, height: int = 400, width: int = 400) -> bool:
+    """
+    Render py3Dmol viewer via Streamlit components. Returns True if rendered.
+    """
+    import streamlit.components.v1 as components
+
+    clean = "".join(c for c in (sequence or "").upper() if not c.isspace())
+    if not clean:
+        return False
+    try:
+        import py3Dmol  # type: ignore
+    except Exception:
+        return False
+
+    try:
+        pdb_data = generate_helix_pdb(clean)
+        view = py3Dmol.view(width=width, height=height)
+        view.addModel(pdb_data, "pdb")
+        for i, aa in enumerate(clean):
+            color = get_residue_color(aa)
+            # py3Dmol residue index is 1-based in this PDB
+            view.setStyle({"resi": i + 1}, {"sphere": {"color": color}})
+        view.zoomTo()
+        if hasattr(view, "_make_html"):
+            html = view._make_html()
+        else:
+            html = view.write()
+        components.html(html, height=height)
+        return True
+    except Exception:
+        return False

requirements.txt

@@ -5,4 +5,5 @@ torch
 scikit-learn
 matplotlib
 plotly
-requests
+requests
+py3dmol