Add correlation tab

.gitignore

@@ -1,3 +1,5 @@
 .envrc
-
-boltz_results/
+**/__pycache__/
+output/
+sequences/
+boltz_results/

Dockerfile

@@ -8,7 +8,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     wget build-essential git && \
     rm -rf /var/lib/apt/lists/*
 
-COPY --from=uv-fetcher /uv /uvx /usr/local/bin/
+COPY --from=uv-fetcher /uv /uvx /bin/
 
 ENV VIRTUAL_ENV=/modules/.venv
 RUN uv venv "$VIRTUAL_ENV" && . "$VIRTUAL_ENV/bin/activate"
@@ -17,34 +17,28 @@ ENV PATH="$VIRTUAL_ENV/bin:$PATH"
 # Set the working directory to the user's home directory
 WORKDIR /app
 
-COPY pyproject.toml uv.lock /app/
+# Create a non-root user and set permissions
+RUN useradd -m -u 1000 appuser && \
+    chown -R appuser:appuser /app
+
+# Switch to non-root user
+USER appuser
 
-RUN uv sync --frozen --active --directory /app --inexact
+COPY pyproject.toml uv.lock README.md ./
+COPY folding-studio ./folding-studio
 
-COPY folding-studio /app/folding-studio
-RUN cd /app/folding-studio && uv pip install -e .
+RUN uv sync --locked --no-install-project --no-dev
+
+COPY folding_studio_demo ./folding_studio_demo
+RUN uv sync --locked --no-dev
 
-COPY app.py /app/app.py
-COPY molecule.py /app/molecule.py
 # COPY pred.cif /app/boltz_results/pred_model_0.cif
 # COPY plddt_0.npz /app/boltz_results/plddt_0.npz
+COPY spr_af_scores_mapped.csv /app/spr_af_scores_mapped.csv
 
 EXPOSE 7860
 ENV GRADIO_SERVER_NAME="0.0.0.0"
-ARG FOLDING_PROJECT_CODE
+ARG FOLDING_PROJECT_CODE="folding_dev"
 ENV FOLDING_PROJECT_CODE=$FOLDING_PROJECT_CODE
 
-# Create directory for HTML output
-RUN mkdir -p /app/output/html
-
-# Create volume for HTML output
-VOLUME ["/app/output/html"]
-
-# Create a non-root user and set permissions
-RUN useradd -m -u 1000 appuser && \
-    chown -R appuser:appuser /app
-
-# Switch to non-root user
-USER appuser
-
-CMD ["python3", "app.py"]
+CMD ["uv", "run", "folding-studio-demo"]

Makefile

@@ -1,5 +1,5 @@
 # Variables
-DOCKER_IMAGE_NAME = folding-studio
+DOCKER_IMAGE_NAME = folding-studio-demo
 DOCKER_IMAGE_TAG = latest
 PORT = 7860
 OUTPUT_DIR = ./output

app.py

@@ -1,213 +0,0 @@
-from Bio.PDB import MMCIFParser, PDBIO
-from folding_studio.client import Client
-from folding_studio.query.boltz import BoltzQuery, BoltzParameters
-from pathlib import Path
-import gradio as gr
-import hashlib
-import logging
-import numpy as np
-import os
-import plotly.graph_objects as go
-
-from molecule import molecule
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(),
-    ]
-)
-logger = logging.getLogger(__name__)
-
-
-def convert_cif_to_pdb(cif_path: str, pdb_path: str) -> None:
-    """Convert a .cif file to .pdb format using Biopython.
-    
-    Args:
-        cif_path (str): Path to input .cif file
-        pdb_path (str): Path to output .pdb file
-    """
-    # Parse the CIF file
-    parser = MMCIFParser()
-    structure = parser.get_structure("structure", cif_path)
-    
-    # Save as PDB
-    io = PDBIO()
-    io.set_structure(structure)
-    io.save(pdb_path)
-
-def call_boltz(seq_file: Path | str, api_key: str, output_dir: Path) -> None:
-    """Call Boltz prediction."""
-    # Initialize parameters with CLI-provided values
-    parameters = {
-        "recycling_steps": 3,
-        "sampling_steps": 200,
-        "diffusion_samples": 1,
-        "step_scale": 1.638,
-        "msa_pairing_strategy": "greedy",
-        "write_full_pae": False,
-        "write_full_pde": False,
-        "use_msa_server": True,
-        "seed": 0,
-        "custom_msa_paths": None,
-    }
-    
-    # Create a client using API key
-    logger.info("Authenticating client with API key")
-    client = Client.from_api_key(api_key=api_key)
-
-    # Define query
-    seq_file = Path(seq_file)
-    query = BoltzQuery.from_file(seq_file, query_name="gradio", parameters=BoltzParameters(**parameters))
-    query.save_parameters(output_dir)
-
-    logger.info("Payload: %s", query.payload)
-
-    # Send a request
-    logger.info("Sending request to Folding Studio API")
-    response = client.send_request(query, project_code=os.environ["FOLDING_PROJECT_CODE"])
-
-    # Access confidence data
-    logger.info("Confidence data: %s", response.confidence_data)
-
-    response.download_results(output_dir=output_dir, force=True, unzip=True)
-    logger.info("Results downloaded to %s", output_dir)
-
-
-def predict(sequence: str, api_key: str) -> str:
-    """Predict protein structure from amino acid sequence using Boltz model.
-    
-    Args:
-        sequence (str): Amino acid sequence to predict structure for
-        api_key (str): Folding API key
-        
-    Returns:
-        str: HTML iframe containing 3D molecular visualization
-    """
-    
-    # Set up unique output directory based on sequence hash
-    seq_id = hashlib.sha1(sequence.encode()).hexdigest()
-    seq_file = Path(f"sequence_{seq_id}.fasta")
-    _write_fasta_file(seq_file, sequence)
-    output_dir = Path(f"sequence_{seq_id}")
-    output_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Check if prediction already exists
-    pred_cif = list(output_dir.rglob("*_model_0.cif"))
-    if not pred_cif:
-        # Run Boltz prediction
-        logger.info(f"Predicting {seq_file.stem}")
-        call_boltz(seq_file=seq_file, api_key=api_key, output_dir=output_dir)
-        logger.info("Prediction done. Output directory: %s", output_dir)
-    else:
-        logger.info("Prediction already exists. Output directory: %s", output_dir)
-
-    # output_dir = Path("boltz_results") # debug
-    # Convert output CIF to PDB
-    pred_cif = list(output_dir.rglob("*_model_0.cif"))[0]
-    logger.info("Output file: %s", pred_cif)
-    
-    converted_pdb_path = str(output_dir / "pred.pdb")
-    convert_cif_to_pdb(str(pred_cif), str(converted_pdb_path))
-    logger.info("Converted PDB file: %s", converted_pdb_path)
-
-
-    # Generate molecular visualization
-    mol = _create_molecule_visualization(
-        converted_pdb_path,
-        sequence,
-    )    
-
-    plddt_file = list(pred_cif.parent.glob("plddt_*.npz"))[0]
-    logger.info("plddt file: %s", plddt_file)
-    plddt_vals = np.load(plddt_file)["plddt"]
-
-    return _wrap_in_iframe(mol), add_plddt_plot(plddt_vals=plddt_vals)
-
-
-def _write_fasta_file(filepath: Path, sequence: str) -> None:
-    """Write sequence to FASTA file."""
-    with open(filepath, "w") as f:
-        f.write(f">A|protein\n{sequence}")
-
-
-def _create_molecule_visualization(pdb_path: Path, sequence: str) -> str:
-    """Create molecular visualization using molecule module."""
-    return molecule(
-        str(pdb_path),
-        lenSeqs=1,
-        num_res=len(sequence),
-        selectedResidues=list(range(1, len(sequence) + 1)),
-        allSeqs=[sequence],
-        sequences=[{
-            "Score": 0,
-            "RMSD": 0, 
-            "Recovery": 0,
-            "Mean pLDDT": 0,
-            "seq": sequence
-        }],
-    )
-
-
-def _wrap_in_iframe(content: str) -> str:
-    """Wrap content in an HTML iframe with appropriate styling and permissions."""
-    return f"""<iframe 
-        name="result" 
-        style="width: 100%; height: 100vh;"
-        allow="midi; geolocation; microphone; camera; display-capture; encrypted-media;"
-        sandbox="allow-modals allow-forms allow-scripts allow-same-origin allow-popups allow-top-navigation-by-user-activation allow-downloads"
-        allowfullscreen=""
-        allowpaymentrequest=""
-        frameborder="0"
-        srcdoc='{content}'
-    ></iframe>"""
-
-def add_plddt_plot(plddt_vals: list[float]) -> str:
-    """Create a plot of metrics."""
-    visible = True
-    plddt_trace = go.Scatter(
-            x=np.arange(len(plddt_vals)),
-            y=plddt_vals,
-            hovertemplate="<i>pLDDT</i>: %{y:.2f} <br><i>Residue index:</i> %{x}<br>",
-            name="seq",
-            visible=visible,
-        )
-    
-    plddt_fig = go.Figure(data=[plddt_trace])
-    plddt_fig.update_layout(
-        title="pLDDT",
-        xaxis_title="Residue index",
-        yaxis_title="pLDDT",
-        height=500,
-        template="simple_white",
-        legend=dict(yanchor="bottom", y=0.01, xanchor="left", x=0.99),
-    )
-    return plddt_fig
-
-demo = gr.Blocks(title="Folding Studio: structure prediction with Boltz-1")
-
-with demo:
-    gr.Markdown("# Input")
-    with gr.Row():
-        with gr.Column():
-            sequence = gr.Textbox(label="Sequence", value="")
-            api_key = gr.Textbox(label="Folding API Key", type="password")
-    gr.Markdown("# Output")
-    with gr.Row():
-        predict_btn = gr.Button("Predict")
-    with gr.Row():
-        with gr.Column():
-            mol_output = gr.HTML()
-        with gr.Column():
-            metrics_plot = gr.Plot(label="pLDDT")
-           
-    predict_btn.click(
-        fn=predict,
-        inputs=[sequence, api_key],
-        outputs=[mol_output, metrics_plot]
-    )
-
-demo.launch()
-

folding_studio_demo/__init__.py

@@ -0,0 +1,12 @@
+"""Folding Studio Demo."""
+
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.StreamHandler(),
+    ],
+)

folding_studio_demo/app.py

@@ -0,0 +1,218 @@
+"""Folding Studio Demo App."""
+
+import logging
+
+import gradio as gr
+from folding_studio_data_models import FoldingModel
+from gradio_molecule3d import Molecule3D
+import pandas as pd
+
+from folding_studio_demo.predict import predict
+from folding_studio_demo.correlate import fake_predict_and_correlate, SCORE_COLUMNS, select_correlation_plot
+
+logger = logging.getLogger(__name__)
+
+
+MOLECULE_REPS = [
+    {
+        "model": 0,
+        "chain": "",
+        "resname": "",
+        "style": "cartoon",
+        "color": "alphafold",
+        # "residue_range": "",
+        "around": 0,
+        "byres": False,
+        # "visible": False,
+        # "opacity": 0.5
+    }
+]
+
+DEFAULT_PROTEIN_SEQ = ">protein description\nMALWMRLLPLLALLALWGPDPAAA"
+
+MODEL_CHOICES = [
+    # ("AlphaFold2", FoldingModel.AF2),
+    # ("OpenFold", FoldingModel.OPENFOLD),
+    # ("SoloSeq", FoldingModel.SOLOSEQ),
+    ("Boltz-1", FoldingModel.BOLTZ),
+    ("Chai-1", FoldingModel.CHAI),
+    ("Protenix", FoldingModel.PROTENIX),
+]
+
+
+def sequence_input() -> gr.Textbox:
+    """Sequence input component.
+
+    Returns:
+        gr.Textbox: Sequence input component
+    """
+    sequence = gr.Textbox(
+        label="Protein Sequence",
+        value=DEFAULT_PROTEIN_SEQ,
+        lines=2,
+        placeholder="Enter a protein sequence or upload a FASTA file",
+    )
+    file_input = gr.File(
+        label="Upload a FASTA file",
+        file_types=[".fasta", ".fa"],
+    )
+
+    def _process_file(file: gr.File | None) -> gr.Textbox:
+        if file is None:
+            return gr.Textbox()
+        try:
+            with open(file.name, "r") as f:
+                content = f.read().strip()
+            return gr.Textbox(value=content)
+        except Exception as e:
+            logger.error(f"Error reading file: {e}")
+            return gr.Textbox()
+
+    file_input.change(fn=_process_file, inputs=[file_input], outputs=[sequence])
+    return sequence
+
+
+def simple_prediction(api_key: str) -> None:
+    """Simple prediction tab.
+
+    Args:
+        api_key (str): Folding Studio API key
+    """
+    gr.Markdown(
+        """
+        ### Predict a Protein Structure
+
+        It will be run in the background and the results will be displayed in the output section.
+        The output will contain the protein structure and the pLDDT plot.
+
+        Select a model to run the inference with and enter a protein sequence or upload a FASTA file.
+        """
+    )
+    with gr.Row():
+        dropdown = gr.Dropdown(
+            label="Model",
+            choices=MODEL_CHOICES,
+            scale=0,
+            value=FoldingModel.BOLTZ,
+        )
+        with gr.Column():
+            sequence = sequence_input()
+
+    predict_btn = gr.Button("Predict")
+
+    with gr.Row():
+        mol_output = Molecule3D(label="Protein Structure", reps=MOLECULE_REPS)
+        metrics_plot = gr.Plot(label="pLDDT")
+
+    predict_btn.click(
+        fn=predict,
+        inputs=[sequence, api_key, dropdown],
+        outputs=[mol_output, metrics_plot],
+    )
+
+
+def model_comparison(api_key: str) -> None:
+    """Model comparison tab.
+
+    Args:
+        api_key (str): Folding Studio API key
+    """
+
+    with gr.Row():
+        model = gr.Dropdown(
+            label="Model",
+            choices=MODEL_CHOICES,
+            multiselect=True,
+            scale=0,
+            min_width=300,
+            value=[FoldingModel.BOLTZ, FoldingModel.CHAI, FoldingModel.PROTENIX],
+        )
+        with gr.Column():
+            sequence = sequence_input()
+
+    predict_btn = gr.Button("Compare Models")
+
+    with gr.Row():
+        mol_output = Molecule3D(label="Protein Structure", reps=MOLECULE_REPS)
+        metrics_plot = gr.Plot(label="pLDDT")
+
+    predict_btn.click(
+        fn=predict,
+        inputs=[sequence, api_key, model],
+        outputs=[mol_output, metrics_plot],
+    )
+
+
+def create_correlation_tab():
+    gr.Markdown("# Correlation with experimental binding affinity data")
+    spr_data_with_scores = pd.read_csv("spr_af_scores_mapped.csv")
+    prettified_columns = {
+            "antibody_name": "Antibody Name",
+            "KD (nM)": "KD (nM)",
+            "antibody_vh_sequence": "Antibody VH Sequence",
+            "antibody_vl_sequence": "Antibody VL Sequence",
+            "antigen_sequence": "Antigen Sequence"
+        }
+    spr_data_with_scores = spr_data_with_scores.rename(columns=prettified_columns)
+    with gr.Row():
+        columns = [
+            "Antibody Name",
+            "KD (nM)",
+            "Antibody VH Sequence",
+            "Antibody VL Sequence",
+            "Antigen Sequence"
+        ]
+        # Display dataframe with floating point values rounded to 2 decimal places
+        spr_data = gr.DataFrame(value=spr_data_with_scores[columns].round(2), label="Experimental Antibody-Antigen Binding Affinity Data")
+
+    gr.Markdown("# Prediction and correlation")
+    with gr.Row():
+        fake_predict_btn = gr.Button("Predict structures of all complexes")
+    with gr.Row():
+        prediction_dataframe = gr.Dataframe(label="Predicted Structures Data")
+    with gr.Row():
+        correlation_ranking_plot = gr.Plot(label="Correlation ranking")
+    with gr.Row():
+        # User can select the columns to display in the correlation plot
+        correlation_column = gr.Dropdown(label="Score data to display", choices=SCORE_COLUMNS, multiselect=False)
+        correlation_plot = gr.Plot(label="Correlation with binding affinity")
+
+    fake_predict_btn.click(
+        fn=lambda x: fake_predict_and_correlate(spr_data_with_scores, SCORE_COLUMNS, ["Antibody Name", "KD (nM)"]),
+        inputs=None,
+        outputs=[prediction_dataframe, correlation_ranking_plot]
+    )
+
+    # Call function to update the correlation plot when the user selects the columns
+    correlation_column.change(
+        fn=lambda score: select_correlation_plot(spr_data_with_scores, score),
+        inputs=correlation_column,
+        outputs=correlation_plot
+    )
+    
+def __main__():
+    with gr.Blocks(title="Folding Studio Demo") as demo:
+        gr.Markdown(
+            """
+            # Folding Studio: Harness the Power of Protein Folding 🧬
+
+            Folding Studio is a platform for protein structure prediction.
+            It uses the latest AI-powered folding models to predict the structure of a protein.
+
+            Available models are : AlphaFold2, OpenFold, SoloSeq, Boltz-1, Chai and Protenix.
+
+            ## API Key
+            To use the Folding Studio API, you need to provide an API key.
+            You can get your API key by asking to the Folding Studio team.
+            """
+        )
+        api_key = gr.Textbox(label="Folding Studio API Key", type="password")
+        gr.Markdown("## Demo Usage")
+        with gr.Tab("🚀 Simple Prediction"):
+            simple_prediction(api_key)
+        with gr.Tab("📊 Model Comparison"):
+            model_comparison(api_key)
+        with gr.Tab("🔍 Correlations"):
+            create_correlation_tab()
+
+    demo.launch()

folding_studio_demo/correlate.py

@@ -0,0 +1,110 @@
+import logging
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from scipy.stats import spearmanr
+
+logger = logging.getLogger(__name__)
+
+SCORE_COLUMNS = [
+        "confidence_score_boltz",
+        "ptm_boltz",
+        "iptm_boltz", 
+        "complex_plddt_boltz",
+        "complex_iplddt_boltz",
+        "complex_pde_boltz",
+        "complex_ipde_boltz",
+        "interchain_pae_monomer",
+        "interface_pae_monomer",
+        "overall_pae_monomer",
+        "interface_plddt_monomer",
+        "average_plddt_monomer",
+        "ptm_monomer",
+        "interface_ptm_monomer", 
+        "interchain_pae_multimer",
+        "interface_pae_multimer",
+        "overall_pae_multimer",
+        "interface_plddt_multimer",
+        "average_plddt_multimer",
+        "ptm_multimer",
+        "interface_ptm_multimer"
+    ]
+
+def fake_predict_and_correlate(spr_data_with_scores: pd.DataFrame, score_cols: list[str], main_cols: list[str]) -> tuple[pd.DataFrame, go.Figure]:
+    """Fake predict structures of all complexes and correlate the results."""
+    corr_data = []
+    spr_data_with_scores["log_kd"] = np.log10(spr_data_with_scores["KD (nM)"])
+    kd_col = "KD (nM)"
+    for score_col in score_cols:
+        logger.info(f"Computing correlation between {score_col} and KD (nM)")
+        res = spearmanr(spr_data_with_scores[kd_col], spr_data_with_scores[score_col])
+        corr_data.append({"score": score_col, "correlation": res.statistic, "p-value": res.pvalue})
+        logger.info(f"Correlation between {score_col} and KD (nM): {res.statistic}")
+
+    corr_data = pd.DataFrame(corr_data)
+    # Find the lines in corr_data with NaN values and remove them
+    corr_data = corr_data[corr_data["correlation"].notna()]
+    # Sort correlation data by correlation value
+    corr_data = corr_data.sort_values('correlation', ascending=True)
+    
+    # Create bar plot of correlations
+    corr_ranking_plot = go.Figure(data=[
+        go.Bar(
+            x=corr_data["correlation"],
+            y=corr_data["score"], 
+            name="correlation",
+            orientation='h',
+            hovertemplate="<i>Score:</i> %{y}<br><i>Correlation:</i> %{x:.3f}<br>"
+        )
+    ])
+    corr_ranking_plot.update_layout(
+        title="Correlation with Binding Affinity",
+        yaxis_title="Score Type",
+        xaxis_title="Spearman Correlation",
+        template="simple_white",
+        showlegend=False
+    )
+
+    cols_to_show = main_cols[:]
+    cols_to_show.extend(score_cols)
+
+    return spr_data_with_scores[cols_to_show].round(2), corr_ranking_plot
+
+def select_correlation_plot(spr_data_with_scores: pd.DataFrame, score: str) -> go.Figure:
+    """Select the correlation plot to display."""
+    # corr_plot is a scatter plot of the correlation between the binding affinity and each of the scores
+    scatter =  go.Scatter(
+            x=spr_data_with_scores["KD (nM)"],
+            y=spr_data_with_scores[score],
+            name=f"KD (nM) vs {score}",
+            mode='markers',  # Only show markers/dots, no lines
+            hovertemplate="<i>Score:</i> %{y}<br><i>KD:</i> %{x:.2f}<br>",
+            marker=dict(color='#1f77b4')  # Set color to match default first color
+        )   
+    corr_plot = go.Figure(data=scatter)
+    corr_plot.update_layout(
+        xaxis_title="KD (nM)",
+        yaxis_title=score,
+        template="simple_white",
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1
+        )
+        # xaxis_type="log"  # Set x-axis to logarithmic scale
+    )
+    # compute the correlation line
+    corr_line = np.polyfit(spr_data_with_scores["KD (nM)"], spr_data_with_scores[score], 1)
+    corr_line_x = np.linspace(min(spr_data_with_scores["KD (nM)"]), max(spr_data_with_scores["KD (nM)"]), 100)
+    corr_line_y = corr_line[0] * corr_line_x + corr_line[1]
+    # add the correlation line to the plot
+    corr_plot.add_trace(go.Scatter(
+        x=corr_line_x,
+        y=corr_line_y,
+        mode='lines',
+        name=f"Correlation",
+        line=dict(color='#1f77b4')  # Set same color as scatter points
+    ))
+    return corr_plot

folding_studio_demo/model_fasta_validators.py

@@ -0,0 +1,367 @@
+"""Utils for validating the FASTA files for the AF3 like models."""
+
+import logging
+import re
+import shutil
+from abc import abstractmethod
+from collections import defaultdict
+from enum import Enum
+from pathlib import Path
+
+from Bio import SeqIO
+
+
+class EntityType(str, Enum):
+    """Enum for the entity type of a given sequence."""
+
+    DNA = "dna"
+    RNA = "rna"
+    PROTEIN = "protein"
+    PEPTIDE = "peptide"
+    ION = "ion"
+    LIGAND = "ligand"
+    SMILES = "smiles"
+    CCD = "ccd"
+
+
+def get_entity_type(sequence: str) -> EntityType:
+    """Get the entity type of a given sequence.
+
+    The entity type is determined based on the sequence composition.
+
+    Args:
+        sequence (str): The input sequence.
+
+    Returns:
+        EntityType: The entity type of the input sequence.
+    """
+    DNA_SEQUENCE_SET = set("ACGT")
+    RNA_SEQUENCE_SET = set("ACGU")
+    PROTEIN_SEQUENCE_SET = set("ACDEFGHIKLMNPQRSTVWY")
+
+    # Detect IONS (e.g., Mg2+, Na+, Cl-)
+    if re.fullmatch(r"[A-Za-z]{1,2}[\d\+\-]*", sequence):
+        return EntityType.ION
+
+    # Detect DNA
+    if set(sequence.upper()).issubset(DNA_SEQUENCE_SET):
+        return EntityType.DNA
+
+    # Detect RNA
+    elif set(sequence.upper()).issubset(RNA_SEQUENCE_SET):
+        return EntityType.RNA
+
+    # Detect PROTEIN
+    elif set(sequence.upper()).issubset(PROTEIN_SEQUENCE_SET):
+        return EntityType.PROTEIN
+
+    # Default to LIGAND
+    return EntityType.LIGAND
+
+
+def has_multiple_chains(header: str) -> bool:
+    """Check if a given header contains multiple chains in RCSB format.
+
+    A header with multiple chains will have the following in the header:
+    ```
+    Chains A, B, C, ...
+    ```
+    where `A`, `B`, `C`, ... are the chain identifiers.
+
+
+    Args:
+        header (str): The input header string containing chain information.
+
+    Returns:
+        bool: True if the header contains multiple chains, False otherwise.
+    """
+    match = re.search(r"chains?\s+([A-Za-z, ]+)", header, re.I)
+    return len(match.group(1).replace(" ", "").split(",")) > 1 if match else False
+
+
+class BaseFastaValidator:
+    """Base class for validating FASTA files."""
+
+    @abstractmethod
+    def is_valid_fasta(self, fasta_path: Path) -> tuple[bool, str | None]:
+        """Validate whether a given FASTA file follows the required format.
+
+        Args:
+            fasta_path (Path): Path to the FASTA file.
+
+        Returns:
+            tuple[bool, str | None]: Tuple containing a boolean indicating if the format is correct and an error message if not
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+
+    @abstractmethod
+    def transform_fasta(self, fasta_path: Path) -> str:
+        """Transform a FASTA file into the required format.
+
+        Args:
+            fasta_path (Path): Path to the FASTA file.
+
+        Returns:
+            Transformed FASTA content in the required format.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+
+    def process_directory(self, input_dir: str, output_dir: str) -> None:
+        """Process all FASTA files in the input directory, validate or transform them, and save them to the output directory.
+
+        Args:
+            input_dir (str): Path to the directory containing FASTA files.
+            output_dir (str): Path to the output directory where processed files will be saved.
+        """
+
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+
+        for fasta_file in Path(input_dir).glob("*.fasta"):
+            output_file = output_path / fasta_file.name
+            if has_multiple_chains(fasta_file.read_text()):
+                logging.warning(
+                    f"Skipping {fasta_file} because it contains multiple chains in a single sequence.\n"
+                    "Please split multiple chains into separate sequences using the following format:\n"
+                    ">Chain A\n"
+                    "MTEIVLKFL...\n"
+                    ">Chain B\n"
+                    "MTEIVLKFL...\n\n"
+                    "Instead of:\n"
+                    ">Chains A, B\n"
+                    "MTEIVLKFL..."
+                )
+                continue
+            if self.is_valid_fasta(fasta_file):
+                shutil.copy(fasta_file, output_file)
+            else:
+                transformed_content = self.transform_fasta(fasta_file)
+                output_file.write_text(transformed_content)
+
+
+class BoltzFastaValidator(BaseFastaValidator):
+    """Validate whether a given FASTA file follows the required format for Boltz."""
+
+    SUPPORTED_ENTITY_TYPES = {
+        EntityType.PROTEIN,
+        EntityType.RNA,
+        EntityType.DNA,
+        EntityType.SMILES,
+        EntityType.CCD,
+    }
+
+    def is_valid_fasta(self, fasta_path: Path) -> tuple[bool, str | None]:
+        """Validate whether a given FASTA file follows the required format.
+
+        The expected FASTA header format is:
+        ```
+        >CHAIN_ID|ENTITY_TYPE
+        ```
+        where `ENTITY_TYPE` must be one of: "protein", "rna", "dna", "smiles" or "ccd".
+
+        Args:
+            fasta_path (Path): Path to the FASTA file.
+
+        Returns:
+            tuple[bool, str | None]: Tuple containing a boolean indicating if the format is correct and an error message if not
+        """
+        with fasta_path.open("r") as f:
+            for record in SeqIO.parse(f, "fasta"):
+                header_parts = record.id.split("|")
+                if not (1 < len(header_parts) <= 3):
+                    msg = "BOLTZ Validation Error: Invalid header format. Expected '>CHAIN_ID|ENTITY_TYPE'"
+                    return False, msg
+                if header_parts[1].lower() not in self.SUPPORTED_ENTITY_TYPES:
+                    return (
+                        False,
+                        f"BOLTZ Validation Error: Invalid entity type '{header_parts[1]}'. Supported types: {', '.join(self.SUPPORTED_ENTITY_TYPES)}",
+                    )
+        return True, None
+
+    def transform_fasta(self, fasta_path: Path) -> str:
+        """Transform a FASTA file into the '>CHAIN_ID|ENTITY_TYPE|MSA_ID' format.
+
+        This function extracts chain identifiers from the FASTA header and determines
+        the entity type (DNA, RNA, or PROTEIN) based on the sequence composition.
+
+        Args:
+            fasta_path (Path): Path to the FASTA file.
+
+        Returns:
+            Transformed FASTA content in the required format.
+        """
+        transformed_lines = []
+
+        with fasta_path.open("r") as f:
+            for record_index, record in enumerate(SeqIO.parse(f, "fasta")):
+                chain = chr(ord("A") + record_index)
+                # extract entity type
+                entity_type = get_entity_type(str(record.seq))
+                transformed_lines.append(f">{chain.upper()}|{entity_type.value}")
+                # append sequence
+                transformed_lines.append(str(record.seq))
+
+        return "\n".join(transformed_lines)
+
+
+class ChaiFastaValidator(BaseFastaValidator):
+    """Validate whether a given FASTA file follows the required format for Chai."""
+
+    SUPPORTED_ENTITY_TYPES = EntityType.__members__.values()
+
+    def is_valid_fasta(self, fasta_path: Path) -> tuple[bool, str | None]:
+        """Validate whether a given FASTA file follows the required format.
+
+        The expected FASTA header format is:
+        ```
+        >ENTITY_TYPE|name=NAME
+        ```
+        Args:
+            fasta_path (Path): Path to the FASTA file.
+
+        Returns:
+            tuple[bool, str | None]: Tuple containing a boolean indicating if the format is correct and an error message if not
+        """
+
+        seen_names = set()
+        with fasta_path.open("r") as f:
+            for record in SeqIO.parse(f, "fasta"):
+                # validate header format
+                match = re.match(r"^([A-Za-z]+)\|name=([\w\-]+)$", record.description)
+                if not match:
+                    return (
+                        False,
+                        "CHAI Validation Error: Invalid header format. Expected '>ENTITY_TYPE|name=NAME'",
+                    )
+                # validate entity type
+                entity_type, name = match.groups()
+                if entity_type not in self.SUPPORTED_ENTITY_TYPES or not name:
+                    return (
+                        False,
+                        f"CHAI Validation Error: Invalid entity type '{entity_type}'. Supported types: {', '.join(self.SUPPORTED_ENTITY_TYPES)}",
+                    )
+                # check uniqueness of name
+                if name in seen_names:
+                    return (
+                        False,
+                        f"CHAI Validation Error: Duplicate name '{name}'. Each sequence must have a unique name",
+                    )
+                seen_names.add(name)
+                # validate sequence format
+                sequence = str(record.seq).strip()
+                if (
+                    entity_type in {EntityType.PEPTIDE, EntityType.PROTEIN}
+                    and not get_entity_type(sequence) == entity_type
+                ):
+                    return (
+                        False,
+                        f"CHAI Validation Error: Sequence type mismatch. Expected '{entity_type}' but found '{get_entity_type(sequence)}'",
+                    )
+
+        return True, None
+
+    def transform_fasta(self, fasta_path: Path) -> str:
+        """Transform a FASTA file into the '>TYPE|name=NAME' format by ensuring each main header
+        is unique (adding a number if necessary).
+
+        The expected output format is:
+            '>protein|name=NAME'
+            'SEQUENCE'
+
+        Args:
+            fasta_path (Path): Path to the FASTA file.
+
+        Returns:
+            Transformed FASTA content in the required Chai format.
+        """
+        transformed_lines = []
+        header_map = {}
+
+        with fasta_path.open("r") as f:
+            for record in SeqIO.parse(f, "fasta"):
+                main_header = record.description.split("|")[0].strip()
+
+                if main_header not in header_map:
+                    header_map[main_header] = 1
+                    updated_header = main_header
+
+                else:
+                    header_map[main_header] += 1
+                    updated_header = main_header + "_" + str(header_map[main_header])
+
+                entity_type = get_entity_type(str(record.seq))
+                header = f">{entity_type.value}|name={updated_header}"
+
+                transformed_lines.append(header)
+                transformed_lines.append(str(record.seq))
+
+        return "\n".join(transformed_lines)
+
+
+class ProtenixFastaValidator(BaseFastaValidator):
+    """Validate whether a given FASTA file follows the required format for Protenix."""
+
+    def is_valid_fasta(self, fasta_path: Path) -> tuple[bool, str | None]:
+        """Validate whether a given FASTA file follows the required format.
+
+        The expected FASTA header format is:
+        ```
+        > UNIQUE ID[|...]
+        ```
+
+        Args:
+            fasta_path (Path): Path to the FASTA file.
+
+        Returns:
+            tuple[bool, str | None]: Tuple containing a boolean indicating if the format is correct and an error message if not
+        """
+        seen_headers = set()
+
+        with fasta_path.open("r") as f:
+            for record in SeqIO.parse(f, "fasta"):
+                main_header = record.description.split("|")[0].strip()
+                if main_header in seen_headers:
+                    return (
+                        False,
+                        f"PROTENIX Validation Error: Duplicate header '{main_header}'. Each sequence must have a unique header",
+                    )
+                seen_headers.add(main_header)
+
+        return True, None
+
+    def transform_fasta(self, fasta_path: Path) -> str:
+        """Transform a FASTA file into the '>NAME|Chain X' format by ensuring each main header
+        is unique (adding a number if necessary).
+
+        The expected output format is:
+            '>protein_1 | Chain A'
+            'SEQUENCE'
+            '>protein_2 | Chain B'
+            'SEQUENCE'
+
+        Args:
+            fasta_path (Path): Path to the FASTA file.
+
+        Returns:
+            Transformed FASTA content in the required Protenix format.
+        """
+        transformed_lines = []
+        header_count = defaultdict(int)
+
+        with fasta_path.open("r") as f:
+            for record in SeqIO.parse(f, "fasta"):
+                header_parts = [part.strip() for part in record.description.split("|")]
+                main_header = header_parts[0]
+
+                # Ensure unique headers
+                header_count[main_header] += 1
+                updated_main_header = (
+                    f"{main_header}_{header_count[main_header]}"
+                    if header_count[main_header] > 1
+                    else main_header
+                )
+
+                transformed_lines.append(f">{updated_main_header}")
+                transformed_lines.append(str(record.seq))
+
+        return "\n".join(transformed_lines)

molecule.py → folding_studio_demo/molecule.py

@@ -1,15 +1,16 @@
-import logging 
+import logging
 
 # Configure logging
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
+    format="%(asctime)s - %(levelname)s - %(message)s",
     handlers=[
         logging.StreamHandler(),
-    ]
+    ],
 )
 logger = logging.getLogger(__name__)
 
+
 def read_mol(molpath):
     with open(molpath, "r") as fp:
         lines = fp.readlines()
@@ -19,10 +20,7 @@ def read_mol(molpath):
     return mol
 
 
-def molecule(
-    input_pdb, lenSeqs, num_res, selectedResidues, allSeqs, sequences
-):
-
+def molecule(input_pdb, lenSeqs, num_res, selectedResidues, allSeqs, sequences):
     options = ""
     pred_mol = "["
     seqdata = "{"
@@ -265,5 +263,5 @@ def molecule(
         </script>
         </body></html>"""
     )
-    
-    return x
+
+    return x

folding_studio_demo/predict.py

@@ -0,0 +1,279 @@
+"""Predict protein structure using Folding Studio."""
+
+import hashlib
+import logging
+import os
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import plotly.graph_objects as go
+from Bio import SeqIO
+from Bio.PDB import PDBIO, MMCIFParser
+from folding_studio.client import Client
+from folding_studio.query import Query
+from folding_studio.query.boltz import BoltzQuery
+from folding_studio.query.chai import ChaiQuery
+from folding_studio.query.protenix import ProtenixQuery
+from folding_studio_data_models import FoldingModel
+
+from folding_studio_demo.model_fasta_validators import (
+    BaseFastaValidator,
+    BoltzFastaValidator,
+    ChaiFastaValidator,
+    ProtenixFastaValidator,
+)
+
+logger = logging.getLogger(__name__)
+
+SEQUENCE_DIR = Path("sequences")
+SEQUENCE_DIR.mkdir(parents=True, exist_ok=True)
+
+OUTPUT_DIR = Path("output")
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def convert_cif_to_pdb(cif_path: str, pdb_path: str) -> None:
+    """Convert a .cif file to .pdb format using Biopython.
+
+    Args:
+        cif_path (str): Path to input .cif file
+        pdb_path (str): Path to output .pdb file
+    """
+    # Parse the CIF file
+    parser = MMCIFParser()
+    structure = parser.get_structure("structure", cif_path)
+
+    # Save as PDB
+    io = PDBIO()
+    io.set_structure(structure)
+    io.save(pdb_path)
+
+
+def add_plddt_plot(plddt_vals: list[float]) -> str:
+    """Create a plot of metrics."""
+    visible = True
+    plddt_trace = go.Scatter(
+        x=np.arange(len(plddt_vals)),
+        y=plddt_vals,
+        hovertemplate="<i>pLDDT</i>: %{y:.2f} <br><i>Residue index:</i> %{x}<br>",
+        name="seq",
+        visible=visible,
+    )
+
+    plddt_fig = go.Figure(data=[plddt_trace])
+    plddt_fig.update_layout(
+        title="pLDDT",
+        xaxis_title="Residue index",
+        yaxis_title="pLDDT",
+        height=500,
+        template="simple_white",
+        legend=dict(yanchor="bottom", y=0.01, xanchor="left", x=0.99),
+    )
+    return plddt_fig
+
+
+def _write_fasta_file(
+    sequence: str, directory: Path = SEQUENCE_DIR
+) -> tuple[str, Path]:
+    """Write sequence to FASTA file.
+
+    Args:
+        sequence (str): Sequence to write to FASTA file
+        directory (Path): Directory to write FASTA file to (default: SEQUENCE_DIR)
+
+    Returns:
+        tuple[str, Path]: Tuple containing the sequence ID and the path to the FASTA file
+    """
+    seq_id = hashlib.sha1(sequence.encode()).hexdigest()
+    seq_file = directory / f"sequence_{seq_id}.fasta"
+    with open(seq_file, "w") as f:
+        f.write(sequence)
+    return seq_id, seq_file
+
+
+class AF3Model:
+    def __init__(
+        self, api_key: str, model_name: str, query: Query, validator: BaseFastaValidator
+    ):
+        self.api_key = api_key
+        self.model_name = model_name
+        self.query = query
+        self.validator = validator
+
+    def call(self, seq_file: Path | str, output_dir: Path) -> None:
+        """Predict protein structure from amino acid sequence using AF3 model.
+
+        Args:
+            seq_file (Path | str): Path to FASTA file containing amino acid sequence
+            output_dir (Path): Path to output directory
+        """
+        # Validate FASTA format before calling
+        is_valid, error_msg = self.check_file_description(seq_file)
+        if not is_valid:
+            logger.error(error_msg)
+            raise gr.Error(error_msg)
+
+        # Create a client using API key
+        logger.info("Authenticating client with API key")
+        client = Client.from_api_key(api_key=self.api_key)
+
+        # Define query
+        query: Query = self.query.from_file(path=seq_file, query_name="gradio")
+        query.save_parameters(output_dir)
+
+        logger.info("Payload: %s", query.payload)
+
+        # Send a request
+        logger.info(f"Sending {self.model_name} request to Folding Studio API")
+        response = client.send_request(
+            query, project_code=os.environ["FOLDING_PROJECT_CODE"]
+        )
+
+        # Access confidence data
+        logger.info("Confidence data: %s", response.confidence_data)
+
+        response.download_results(output_dir=output_dir, force=True, unzip=True)
+        logger.info("Results downloaded to %s", output_dir)
+
+    def format_fasta(self, sequence: str) -> str:
+        """Format sequence to FASTA format."""
+        return f">{self.model_name}\n{sequence}"
+
+    def predictions(self, output_dir: Path) -> list[Path]:
+        """Get the path to the prediction."""
+        raise NotImplementedError("Not implemented")
+
+    def has_prediction(self, output_dir: Path) -> bool:
+        """Check if prediction exists in output directory."""
+        return any(self.predictions(output_dir))
+
+    def check_file_description(self, seq_file: Path | str) -> tuple[bool, str | None]:
+        """Check if the file description is correct.
+
+        Args:
+            seq_file (Path | str): Path to FASTA file
+
+        Returns:
+            tuple[bool, str | None]: Tuple containing a boolean indicating if the format is correct and an error message if not
+        """
+        input_rep = list(SeqIO.parse(seq_file, "fasta"))
+        if not input_rep:
+            error_msg = f"{self.model_name.upper()} Validation Error: No sequence found"
+            return False, error_msg
+
+        is_valid, error_msg = self.validator.is_valid_fasta(seq_file)
+        if not is_valid:
+            return False, error_msg
+
+        return True, None
+
+
+class ChaiModel(AF3Model):
+    def __init__(self, api_key: str):
+        super().__init__(api_key, "Chai", ChaiQuery, ChaiFastaValidator())
+
+    def call(self, seq_file: Path | str, output_dir: Path) -> None:
+        """Predict protein structure from amino acid sequence using Chai model.
+
+        Args:
+            seq_file (Path | str): Path to FASTA file containing amino acid sequence
+            output_dir (Path): Path to output directory
+        """
+        super().call(seq_file, output_dir)
+
+    def predictions(self, output_dir: Path) -> list[Path]:
+        """Get the path to the prediction."""
+        return list(output_dir.rglob("*_model_[0-9].cif"))
+
+
+class ProtenixModel(AF3Model):
+    def __init__(self, api_key: str):
+        super().__init__(api_key, "Protenix", ProtenixQuery, ProtenixFastaValidator())
+
+    def call(self, seq_file: Path | str, output_dir: Path) -> None:
+        """Predict protein structure from amino acid sequence using Protenix model.
+
+        Args:
+            seq_file (Path | str): Path to FASTA file containing amino acid sequence
+            output_dir (Path): Path to output directory
+        """
+        super().call(seq_file, output_dir)
+
+    def predictions(self, output_dir: Path) -> list[Path]:
+        """Get the path to the prediction."""
+        return list(output_dir.rglob("*_model_[0-9].cif"))
+
+
+class BoltzModel(AF3Model):
+    def __init__(self, api_key: str):
+        super().__init__(api_key, "Boltz", BoltzQuery, BoltzFastaValidator())
+
+    def call(self, seq_file: Path | str, output_dir: Path) -> None:
+        """Predict protein structure from amino acid sequence using Boltz model.
+
+        Args:
+            seq_file (Path | str): Path to FASTA file containing amino acid sequence
+            output_dir (Path): Path to output directory
+        """
+
+        super().call(seq_file, output_dir)
+
+    def predictions(self, output_dir: Path) -> list[Path]:
+        """Get the path to the prediction."""
+        return list(output_dir.rglob("*_model_[0-9].cif"))
+
+
+def predict(sequence: str, api_key: str, model_type: FoldingModel) -> tuple[str, str]:
+    """Predict protein structure from amino acid sequence using Boltz model.
+
+    Args:
+        sequence (str): Amino acid sequence to predict structure for
+        api_key (str): Folding API key
+        model (FoldingModel): Folding model to use
+
+    Returns:
+        tuple[str, str]: Tuple containing the path to the PDB file and the pLDDT plot
+    """
+
+    # Set up unique output directory based on sequence hash
+    seq_id, seq_file = _write_fasta_file(sequence)
+    output_dir = OUTPUT_DIR / seq_id / model_type
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    if model_type == FoldingModel.BOLTZ:
+        model = BoltzModel(api_key)
+    elif model_type == FoldingModel.CHAI:
+        model = ChaiModel(api_key)
+    elif model_type == FoldingModel.PROTENIX:
+        model = ProtenixModel(api_key)
+    else:
+        raise ValueError(f"Model {model_type} not supported")
+
+    # Check if prediction already exists
+    if not model.has_prediction(output_dir):
+        # Run Boltz prediction
+        logger.info(f"Predicting {seq_id}")
+        model.call(seq_file=seq_file, output_dir=output_dir)
+        logger.info("Prediction done. Output directory: %s", output_dir)
+    else:
+        logger.info("Prediction already exists. Output directory: %s", output_dir)
+
+    # output_dir = Path("boltz_results")  # debug
+
+    # Convert output CIF to PDB
+    if not model.has_prediction(output_dir):
+        raise gr.Error("No prediction found")
+
+    pred_cif = model.predictions(output_dir)[0]
+    logger.info("Output file: %s", pred_cif)
+
+    converted_pdb_path = str(output_dir / f"pred_{seq_id}.pdb")
+    convert_cif_to_pdb(str(pred_cif), str(converted_pdb_path))
+    logger.info("Converted PDB file: %s", converted_pdb_path)
+
+    plddt_file = list(pred_cif.parent.glob("plddt_*.npz"))[0]
+    logger.info("plddt file: %s", plddt_file)
+    plddt_vals = np.load(plddt_file)["plddt"]
+
+    return converted_pdb_path, add_plddt_plot(plddt_vals=plddt_vals)

pyproject.toml

@@ -1,12 +1,27 @@
 [project]
-name = "fs"
+name = "folding-studio-demo"
 version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
     "gradio==5.30.0",
+    "gradio-molecule3d>=0.0.7",
     "ipython>=9.2.0",
+    "jupyter>=1.1.1",
     "numpy>=2.2.6",
     "plotly>=6.1.1",
+    "scipy>=1.15.3",
+    "folding-studio",
+    "biopython>=1.85",
 ]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv.sources]
+folding-studio = { path = "./folding-studio" }
+
+[project.scripts]
+folding-studio-demo = "folding_studio_demo.app:__main__"

spr_af_scores_mapped.csv

@@ -0,0 +1,16 @@
+antibody_name,antigen_lineage,kon (1/µM 1/s),koff (1/s),KD (nM),source_name,source_doi,pdb_id,antigen_chain_ids,antibody_heavy_chain_id,antibody_light_chain_id,structure_release_date,structure_resolution,gene_id,antigen_host,antigen_residue_indices,antigen_residue_indices_trimmed,antigen_domain,antibody_light_chain_host,epitope_residues,epitope_mutations,mutations,lineage_mutations_in_epitope,epitope_domain,epitope_is_multichain,epitope_isin_wt,paratope_residues,antibody_vh_sequence,antibody_vl_sequence,spike_sequence,antigen_sequence,antigen_sequence_without_indels,antigen_sequence_trimmed,antigen_sequence_trimmed_without_indels,antigen_pdb_sequence,antigen_pdb_sequence_trimmed,confidence_score_boltz,ptm_boltz,iptm_boltz,ligand_iptm_boltz,protein_iptm_boltz,complex_plddt_boltz,complex_iplddt_boltz,complex_pde_boltz,complex_ipde_boltz,interchain_pae_monomer,interface_pae_monomer,overall_pae_monomer,interface_plddt_monomer,average_plddt_monomer,ptm_monomer,interface_ptm_monomer,interchain_pae_multimer,interface_pae_multimer,overall_pae_multimer,interface_plddt_multimer,average_plddt_multimer,ptm_multimer,interface_ptm_multimer
+bd45_43;covox_269,B,0.293,0.00151,5.162393162,huhn_2025_spr,10.1038/s41467-024-54916-5,7neh,E,H,L,02/04/21,1.77,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(332, 527)",,RBD,homo sapiens (9606),R403 D405 E406 R408 T415 G416 K417 D420 Y421 Y453 L455 F456 R457 K458 S459 N460 Y473 Q474 A475 G476 F486 N487 Y489 Q493 S494 Y495 G496 F497 Q498 N501 Y505,,,,RBD,False,True,H:N30 R31 N32 Y33 Y52 S53 G54 G55 S56 F58 R94 D95 F96 Y97 E98 D101;L:S30 S31 Y32 Q90 L91 N92 S93 Y94,QVQLVESGGGLIQPGGSLRLSCAASGLTVNRNYMSWIRQAPGKGLEWVSVIYSGGSTFYADSVKGRFTISRDNSKNTLSLQMNSLRAEDTAIYYCARDFYEGSFDIWGQGTMVTVSS,AIQLTQSPSFLSASIGDRVTITCRASQGISSYLAWYQQKPGKAPKLLIYAASTLQSGVPSRFSGSGSGTEFTLTISSLQPEDFASYYCQQLNSYPAPVFGPGTKVDIK,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,ITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGP,ITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGP,,,-TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGK,,0.815568387508392,0.631265461444855,0.499751955270767,0.0,0.499751955270767,0.894522488117218,0.808752834796906,0.574461817741394,4.69568395614624,3.723450183868408,2.065487838091536,3.046133041381836,97.62024275169595,97.58975656824344,0.9224043719056731,0.8713607670503896,29.375048637390137,27.4414244016436,28.373729705810547,29.83158417666077,31.749196704388066,0.1932366931512888,0.1605053034841711
+bd45_41;covox_384,B,0.7466666666666667,0.0043133333333333,6.0200266319999995,huhn_2025_spr,10.1038/s41467-024-54916-5,7bep,C,D,F,12/24/20,2.61,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(332, 528)",,RBD,homo sapiens (9606),L452 L455 F456 I472 G482 V483 E484 G485 F486 Y489 F490 L492,,,,RBD,False,True,F:S30 Y32 N92 N93 A94 L95;D:Y50 R52 H55 T56 Y58 L98 F100 L100A E100B W100C,EVQLVESGGGLVKPGESLRLSCAASGFTFSDYYMTWIRQAPGKGLEWVSYIRSSGHTIYYADSVKGRFTISRDNAKNSLYLQMNSLRVEDTAVYYCARGGVLRFLEWPLNAFDIWGQGTMVTVSS,DIQLTQSPSSLSASVGDRVTITCRASQGISNYLAWYQQKPGKVPKLLIYAASTLQSGVPSRFSGSGSGTDFTLTISSLQPEDVATYYCQKYNNALGTFGQGTKVEIK,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,ITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPK,ITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPK,,,-TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGKK,,0.783776104450226,0.566782534122467,0.427239209413528,0.0,0.427239209413528,0.87291032075882,0.786508798599243,0.867737531661987,9.8238639831543,4.809793472290039,2.045966428021883,3.723745822906494,97.230994247972,97.19396149825464,0.8891827579215439,0.8724955180116689,29.54940414428711,27.382281917096904,28.28030586242676,31.741909817932445,35.71164433102995,0.2412751374627494,0.1611393982227129
+covox_58,B,0.479,0.00415,10.472440945,huhn_2025_spr,10.1038/s41467-024-54916-5,7qny,E,A,B,12/23/21,2.84,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(334, 516)",,RBD,homo sapiens (9606),E340 V341 A344 T345 R346 F347 A348 S349 A352 N354 K356 S399 K444 Y449 N450 R466,,,,RBD,False,True,A:S52 W52A N53 S54 G55 T56 I57 G58 T99 F100 V100B L100C;B:S95 D95A,QVQLVESGGGLVQPGRSLRLSCAASGFTFDDYAMHWVRQPPGKGLEWVSGVSWNSGTIGYADSVKGRFIISRDNAKNSLYLQMNSLKAEDTALYYCAREVGGTFGVLISREGGLDYWGQGTLVTVSS,SYELTQPPSVSVAPGQTARITCGGNTIGSKSVHWYQQRPGQAPVLVVYDDSDRPSGIPERFSGSNSGNTATLTISRVEAGDEADYYCQVWDSSSDRVVFGGGTKLTVL,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,NLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFE,NLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFE,,,NLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFE,,0.813834190368652,0.623498022556305,0.497233539819717,0.0,0.497233539819717,0.892984330654144,0.831231832504273,0.777176558971405,6.74987268447876,3.416905641555786,2.73430979206958,3.271117687225342,95.47922926078462,96.64388937350576,0.9293244224193686,0.8333618649239609,29.62367248535156,27.908499213470808,28.87879753112793,27.93079605430594,28.99558687866513,0.1632285223405918,0.1555844490249545
+covox_278,B,0.4905,0.006315,12.865473560000002,huhn_2025_spr,10.1038/s41467-024-54916-5,7or9,E,H,L,06/04/21,2.34,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(333, 527)",,RBD,homo sapiens (9606),T345 R346 Y351 N440 L441 D442 S443 K444 V445 G446 G447 N448 Y449 N450 Y451 L452 T470 E484 F490 L492 P499,,,,RBD,False,True,H:I30 R31 W50 N53 Y56 N58 I98 L99 T100 G100A Y100B L100C D100D;L:A30 S31 Y32 L33 A50 S52 S91 Y92 S93 T94 L95,QVQLVQSGAEVKKPGASVKVSCKASGYIFIRYGISWVRQAPGQGLEWMGWISANNGYTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARDGGILTGYLDYFDHWGQGTLVTVSS,DIQMTQSPSSLSASVGDRLTITCRASQSIASYLNWYQQKPGKAPKLLIYAASSLQSGVPSRFSGSGSGTDFTLTISSLQPEDFATYHCQQSYSTLGITFGPGTKVDIK,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGP,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGP,,,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGK,,0.780656039714813,0.592200815677643,0.456630498170853,0.0,0.456630498170853,0.861662447452545,0.78568172454834,0.749391078948975,6.61570310592651,3.967527985572815,1.887516614885252,3.1754387617111206,97.71261536639231,97.2269496569076,0.922128938711486,0.8817608181456824,29.532506942749023,26.75908168640427,27.047605514526367,42.820148956954306,52.943542943851064,0.3415059963152309,0.1679752252684513
+bd45_39;covox_45,B,0.2276666666666666,0.0065266666666666,28.70041021666667,huhn_2025_spr,10.1038/s41467-024-54916-5,7bel,X,C,D,12/23/20,2.53,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(334, 527)",,RBD,homo sapiens (9606),W353 N354 R355 K356 R357 I358 S359 N360 N394 Y396 P426 D428 K462 P463 F464 E465 R466 I468 E516 L518,,,,RBD,False,True,C:T31 Y32 S52 Y52A D53 S55 N56 Y58 K94 S97 Y98 A99 Y100 Y100A Y100B Y100C D101;D:N31 Y32 Y49 D50 N53 L54 E55 D92 N93,QVQLVESGGGVVQPGRSLRLSCAASGFTFSTYAMHWVRQAPGKGLEWVAVLSYDGSNKYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAKGGSYAYYYYMDVWGKGTTVTVSS,DIQLTQSPSSLSASVGDRVTITCQASQDISNYLNWYQQKPGKAPKLLIYDASNLETGVPSRFSGGGSGTDFTFTITSLQPEDIATYYCQQYDNLPLTFGGGTKVDIK,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,NLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGP,NLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGP,,,NLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGK,,0.864258110523224,0.750974237918854,0.670291066169739,0.0,0.670291066169739,0.912749826908112,0.863511741161346,0.518989622592926,4.14870548248291,3.968512177467346,2.542677193895171,3.364487648010254,96.57266771591796,97.10952461348532,0.914509605012032,0.8440767834045971,29.85724639892578,28.17639105213889,29.10641288757324,28.077718924878248,29.73296412083579,0.1647350462688318,0.1528304609817936
+covox_253,B,0.69975,0.0343125,68.8637716275,huhn_2025_spr,10.1038/s41467-024-54916-5,7ben,C,D,F,12/24/20,2.5,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(336, 516)",,RBD,homo sapiens (9606),K417 Y421 Y453 L455 F456 R457 K458 Y473 Q474 A475 G476 S477 T478 P479 G485 F486 N487 C488 Y489 Q493,,,,RBD,False,True,D:T30 T31 S32 A33 W50 V52 G53 S54 N56 P95 S99 T100 S100A C100B Y100C D100D A100E F100F;F:S31 Y32 Y91 G92 Y96,QVQLVQSGPEVKKPGTSVKVSCKASGFTFTTSAVQWVRQARGQRLEWIGWIVVGSGNTNYAQKFQERVTITRDMSTTTAYMELSSLRSEDTAVYFCAAPHCNSTSCYDAFDIWGQGTMVTVSS,DIQMTQSPGTLSLSPGEGATLSCRASQSVSSSYLAWYQQKPGQAPRLLIYGASSGATGIPDRFSGSGSGTDFTLTISRLEPEDFAVYYCQQYGSSPYTFGQGTKVEIK,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,CPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFE,CPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFE,,,CPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFE,,0.914573848247528,0.883981227874756,0.856384038925171,0.0,0.856384038925171,0.929121315479279,0.915573418140411,0.315263271331787,0.520528972148895,4.548707008361816,2.2264484833746336,3.614177465438843,97.53705417062714,96.7483133214709,0.9031158034443396,0.8620604364444605,26.547210693359375,25.422632414234357,26.56904697418213,37.23036184257237,49.15953242545456,0.4282457681214566,0.1836282104429391
+bd45_42;covox_316,B,0.4048,0.04032,102.189625528,huhn_2025_spr,10.1038/s41467-024-54916-5,7beh,E,H,L,12/23/20,2.3,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(333, 527)",,RBD,homo sapiens (9606),Y449 Y453 L455 F456 V483 E484 G485 F486 N487 C488 Y489 F490 L492 Q493 S494,,,,RBD,False,True,H:T30 G31 Y33 W50 N52 N53 S54 G56 N58 F98 S99 M100 V100A R100B;L:Y30C Y32 Y91 N95 W96,QVQLVQSGAEVKKPGASVKVSCKASGYTFTGYYMHWVRQAPGQGLEWMGWINPNSGGTNYTQKFQGRVTMTRDTSISTAYMELSRLRSDDTAVYSCARDMAFSMVRGSFDYWGQGTLVTVSS,QAVLTQPPSASGSPGQSVTISCTGTSSDVGGYNYVSWYQQHPGKAPKLMIYEVSKRPSGVPDRFSGSKSGNTASLTVSGLQAEDEADYYCSSYAGSNHWVFGGGTKLTVL,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGP,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGP,,,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGK,,0.836899876594544,0.708972632884979,0.600401759147644,0.0,0.600401759147644,0.896024405956268,0.814204096794128,0.500937461853027,3.40170907974243,3.9755221605300903,2.4679562958916876,3.3112473487854004,97.23949349040056,97.2444966855708,0.920971468523108,0.8482919517430124,29.79031562805176,17.87317807569991,25.04682159423828,59.24685751554468,57.925111098887655,0.5151529747182887,0.3037515428354363
+bd45_38;covox_75,B,0.0959999999999999,0.0313285714285714,343.82737152857146,huhn_2025_spr,10.1038/s41467-024-54916-5,7ben,C,G,I,12/24/20,2.5,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(336, 516)",,RBD,homo sapiens (9606),N440 L441 D442 S443 K444 V445 G446 G447 N448 Y449 N450 L452 E484 F490 L492 Q493 S494 Y495 G496,,,,RBD,False,True,I:S30 S31 W32 A50 A91 K92 S93 F94 F96;G:V98 V100 A100A A100B R100C N100D H100E Y100F Y100G N100H,QVQLVESGGGVVQPGRSLRLSCAASGFTFNNYPLHWVRQAPGKGPEWVAVISQDGGNKYYVDSVKGRFTISRDNSKNTLYLQMNNLRAEDTALYYCARDVVVVVAARNHYYNGMDVWGQGTTVTVSS,DIQLTQSPSSVSASVGDRVTITCRASQGISSWLAWYQQKPGKAPKLLIYAVSSLQSGVPSRFSGSGSGTDFTLTISSLQPEDFATYYCQQAKSFPFTFGPGTKVEIK,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,CPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFE,CPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFE,,,CPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFE,,0.801655769348145,0.594999551773071,0.457680195569992,0.0,0.457680195569992,0.887649655342102,0.804755747318268,0.705984234809876,5.93294382095337,4.286665439605713,2.027977637602458,3.3147683143615723,97.71978281117325,96.8930778481744,0.9159003126831424,0.8735424882781723,26.957773208618164,25.519889059658937,26.960838317871097,37.47481094984693,47.88164702045448,0.4208675533072618,0.1824414576700511
+amubarvimab;bd45_21;brii_196;p2c_1f11,B,,,2.12,ju_2020_nature,10.1038/s41586-020-2380-z,7e8m,E,H,L,03/02/21,2.09,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(333, 527)",,RBD,homo sapiens (9606),R403 T415 G416 N417 D420 Y421 Y453 L455 F456 R457 K458 S459 N460 Y473 Q474 A475 F486 N487 Y489 Q493 S494 Y495 Y501 Y505,K417N N501Y,,,RBD,False,False,H:S30 S31 N32 Y33 Y52 S53 G54 G55 S56 Y58 R94 L96 V97 V98 Y99 D101;L:S30 S30A S31 Y32 Q90 Y91 G92 S93,EVQLVESGGGLVQPGGSLRLSCAASGITVSSNYMNWVRQAPGKGLEWVSLIYSGGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYHCARDLVVYGMDVWGQGTTVTVSS,EIVLTQSPGTLSISPGERATLSCRASQSVSSSYLAWYQQKPGQAPRLLIYGASSRATGIPDRFSGSGSGTDFTLTISRLEPEDFAVYYCQQYGSSPTFGQGTKLEIK,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGP,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGP,,,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGNIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVKGFNCYFPLQSYGFQPTYGVGYQPYRVVVLSFELLHAPATVCGP,,0.806627571582794,0.604901313781738,0.469731539487839,0.0,0.469731539487839,0.890851616859436,0.782432734966278,0.653874278068543,5.79969501495361,3.889882802963257,2.1447279756893742,3.1076622009277344,97.63849821703336,97.03031474832582,0.9184391725953712,0.8667697875832223,29.34839630126953,27.19294934209429,28.324119567871097,28.5653600028306,32.27080636498517,0.2005613357989986,0.1631862178489821
+bd45_7;p2b_2f6,B,,,5.14,ju_2020_nature,10.1038/s41586-020-2380-z,8dcc,E,H,L,07/06/22,2.57,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(333, 526)",,RBD,homo sapiens (9606),Y351 K444 G446 G447 N448 Y449 N450 L452 I472 V483 E484 G485 F490 L492 Q493 S494,,,,RBD,False,True,H:S30 S31 G31A Y32 H53 G98 I99 V100 V100A V100B P100C R100H;L:G30B Y30C N31 Y32 E50,QVQLQESGPGLVKPSETLSLTCTVSGYSISSGYYWGWIRQPPGKGLEWIGSIYHSGSTYYNPSLKTRVTISVDTSKNQFSLKLSSVTAADTAVYYCARAVVGIVVVPAAGRRAFDIWGQGTMVTVSS,QSALTQPPSASGSPGQSVTISCTGTSSDVGGYNYVSWYQQHPGKAPKLMIYEVSKRPSGVPDRFSGSKSGNTASLTVSGLQAEDEADYYCSSYAGSNNLVFGGGTKLTVL,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCG,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCG,,,KNLCPFGEVFNATRFASVYAWNRKRISNCVYDYSVLYNSASFSTFKCYGVSPTKLKDLCFTYVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDTSTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLTFELLDAPPTVCG,,0.779910862445831,0.605188310146332,0.472482472658157,0.0,0.472482472658157,0.856767952442169,0.776917576789856,0.806709885597229,7.29232597351074,4.219140529632568,2.249224998168091,3.4182815551757812,97.19018392155026,97.32025286418748,0.9073658369599488,0.8607524475911202,29.55217933654785,27.74894137274779,28.309181213378903,30.19989435806049,34.6484895742348,0.2291970218536952,0.1572482637418456
+bd45_22;p2c_1a3,B,,,2.47,ju_2020_nature,10.1038/s41586-020-2380-z,7cdj,E,H,L,06/19/20,3.4,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(333, 526)",,RBD,homo sapiens (9606),Y449 L452 L455 F456 G476 S477 T478 P479 C480 N481 V483 E484 G485 F486 N487 Y489 F490 L492 Q493 S494,,,,RBD,False,True,L:S30 Y32 L91 N92 S93 Y94;H:Y33 Y50 S52 S52A S53 G54 S55 T56 F96 S97 H98 Q99 Q100 L100A,QVQLVESGGGLVKPGGSLRLSCAASGFTFSDYYMSWIRQAPGKGLEWVSYISSSGSTIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCARDFSHQQLVPSWGQGTLVTVSS,DIQLTQSPSFLSASVGDRVTITCRASQGISSYLAWYQQKPGKAPKLLIYAASTLQSGVPSRFSGSGSGTEFTLTISSLQPEDFATYYCQQLNSYPLTFGGGTKVEIK,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCG,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCG,,,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCG,,0.804550170898438,0.655625939369202,0.529589176177979,0.0,0.529589176177979,0.873290419578552,0.78179919719696,0.559738159179688,4.29560947418213,4.319523096084595,2.2729202048269994,3.5641493797302246,96.98280673538328,96.97517601506055,0.9009612852404294,0.859393807173975,29.33012962341309,27.404896638158995,28.285560607910156,29.053955817539126,31.906904000955564,0.1927061390351921,0.1608966397629959
+p22a_1d1,B,,,5.79,zhang_2021_nat_comms,10.1038/s41467-021-24514-w,7chs,E,H,L,07/06/20,2.4,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(333, 526)",,RBD,homo sapiens (9606),R403 D405 E406 T415 G416 K417 D420 Y421 Y453 L455 F456 R457 K458 S459 N460 Y473 Q474 A475 F486 N487 Y489 F490 L492 Q493 Y495 G496 F497 Q498 N501 Y505,,,,RBD,False,True,H:S30 S31 N32 Y33 Y52 S53 G54 G55 S56 Y58 R94 R96 D97 Y98 Y99 D101;L:S30 Y32 H90 L91 N92 Y94,EVQLVESGGGLIQPGGSLRLSCAASGFTVSSNYMSWVRQAPGKGLEWVSVIYSGGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCARDRDYYGMDVWGQGTTVTVSS,DIQLTQSPSFLSASVGDRVTITCRASQGISSYLAWYQQKPGKAPKLLIYAASTLQSGVPSRFSGSGSGTEFTLTISSLQPEDFATYYCLHLNSYRTFGLGTKVEIK,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCG,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCG,,,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCG,,0.799001395702362,0.583963930606842,0.443157732486725,0.0,0.443157732486725,0.887962281703949,0.783845901489258,0.580890655517578,4.91616106033325,3.8282817602157593,2.26178554607675,3.11441421508789,97.40743986108662,96.75478221302072,0.919711764602881,0.8600319811246402,29.322518348693848,27.32672814436949,28.218334197998047,29.90523019047135,33.48768084795022,0.2129387496796693,0.1617372981596133
+p5a_1d2,B,,,14.02,zhang_2021_nat_comms,10.1038/s41467-021-24514-w,7cho,A,B,C,07/06/20,2.56,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(333, 526)",,RBD,homo sapiens (9606),R403 D405 T415 G416 K417 D420 Y421 Y453 L455 F456 R457 K458 S459 N460 Y473 Q474 A475 F486 N487 Y489 Q493 N501 G502 G504 Y505,,,,RBD,False,True,B:S30 S31 N32 Y33 Y52 S53 G54 G55 S56 Y58 R94 L96 Q97 V98 G99 A100 T100A D100C D101;C:G30A A30B G30C Y31 S95A,EVQLVESGGGLIQPGGSLRLSCAASGFIVSSNYMSWVRQAPGKGLEWVSIIYSGGSTYYADSVKGRFTISRDNSNNTLYLQMNSLRAEDTAVYYCARALQVGATSDYFDYWGQGTLVTVSS,QSVLTQPPSVSGAPGQRVTISCTGSSSNIGAGYDVHWYQQLPGTAPKLLIYGNSNRPSGVPDRFSGSKSGTSASLAITGLQAEDETDYYCQSCDSSLSVVVFGGGTKLTVL,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCG,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCG,,,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCG,,0.840566754341126,0.695268392562866,0.592147290706635,0.0,0.592147290706635,0.902671635150909,0.818431437015533,0.5360067486763,3.70838093757629,4.224268436431885,2.5905382789884297,3.5311367511749268,95.49891960723396,95.8846969442526,0.9089658019474836,0.8413878468162714,29.70927906036377,27.910024175490378,28.62742042541504,28.847876247700896,31.60096486393412,0.19691031850727,0.155568632470583
+p5a_3c8,B,,,1.3,zhang_2021_nat_comms,10.1038/s41467-021-24514-w,7chp,E,H,L,07/06/20,2.36,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(333, 522)",,RBD,homo sapiens (9606),R403 D405 E406 R408 T415 G416 K417 D420 Y421 Y449 Y453 L455 F456 R457 K458 S459 N460 Y473 Q474 A475 F486 N487 Y489 Q493 S494 Y495 G496 F497 Q498 N501 Y505,,,,RBD,False,True,L:S30 S31 Y32 H90 L91 N92 S93 Y94;H:S31 N32 Y33 Y52 S53 G54 G55 S56 Y58 R94 L96 Q97 E98 H99 D101,EVQLVESGGGLIQPGGSLRLSCAASGFTVSSNYMSWVRQAPGKGLEWVSFIYSGGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCARDLQEHGMDVWGQGTTVTVSS,DIQLTQSPSSLSASVGDRVTITCRASQGISSYLAWYQQKPGKAPKLLIYAASTLQSGVPSRFSGSGSGTDFTLTISSLQPEDFATYYCQHLNSYPPGYTFGQGTKLEIK,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPA,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPA,,,TNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPA,,0.799769759178162,0.636229515075684,0.505165874958038,0.0,0.505165874958038,0.873420715332031,0.791917443275452,0.623001635074616,4.9553861618042,3.5803418159484863,1.945987765655582,2.9488518238067627,97.97371806493044,96.72675060619106,0.9255255894656254,0.8783303373121849,29.55667209625244,27.446456582910205,28.21571350097656,29.73038928410532,33.446187252617214,0.2329041029431821,0.1604514663965165
+p5a_3c12,B,,,8.47,zhang_2021_nat_comms,10.1038/s41467-021-24514-w,7d0d,A,H,L,09/09/20,3.8,S,severe acute respiratory syndrome coronavirus 2 (2697049),"(27, 1146)","(327, 528)",spike,homo sapiens (9606),G416 K417 F456 A475 V483 E484 G485 F486 N487 Y489 F490 Q493,,,,RBD,False,True,L:Y30A S30C N30D N30E Y91;H:S31A L50 Y52 W53 D54 D56 R58 F97 L98 T99 Y100B,QITLKESGPTLVKPTQTLTLTCTFSGFSLSTSGVGVGWIRQPPGKALEWLALIYWDDDKRYSPSLKSRLTITKDTSKNQVVLTMTNMDPVDTATYYCAHSLFLTVGYSSSWSPFDYWGQGTLVTVSS,DIVMTQSPDSLAVSLGERATINCKSSQSVLYSSNNKNYLAWYQQKPGQPPKLLIYWASTRESGVPDRFSGSGSGTDFTLTISSLQAEDVAVYYCQQYYSTPHTFGQGTKLEIK,MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT,AYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELD,AYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELD,VRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPK,VRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPK,AYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDPPEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELD,VRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPK,0.801107525825501,0.621712863445282,0.496211916208267,0.0,0.496211916208267,0.877331376075745,0.781339168548584,0.592956483364105,4.11549758911133,7.736447334289551,6.066557600040628,6.794885158538818,82.95154693193497,90.5823181115092,0.8142294848482255,0.6673523088520965,29.801297187805176,27.44481049316726,28.826437950134277,27.01779102581493,30.210954111641698,0.2179942246544585,0.1604690751968928