Bio2Byte_AlphaFold_Analysis.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Bio2Byte - AlphaFold Analysis",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [
        "KI1v2KsXlBNK"
      ],
      "authorship_tag": "ABX9TyP+tNA2DcFiYYWYar60MbNV",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Bio2Byte/public_notebooks/blob/main/Bio2Byte_AlphaFold_Analysis.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hBGCerH1FS5N"
      },
      "source": [
        "# The bio2Byte Toolkit to analyze AlphaFold results\n",
        "\n",
        "This Jupyter Notebook on Google Colab aims to simplify the analysis of the predicted three-dimensional structure after running AlphaFold with your sequence of interest. \n",
        "\n",
        "## About bio2Byte\n",
        "\n",
        "<img src=\"https://pbs.twimg.com/profile_images/1247824923546079232/B9b_Yg7n.jpg\" alt=\"b2b\" width=\"48\"/>\n",
        "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/3/31/Vrije_Universiteit_Brussel_logo.svg/1200px-Vrije_Universiteit_Brussel_logo.svg.png\" alt=\"vub\" width=\"120\"/>\n",
        "\n",
        "Proteins are the molecular machines that make cells work. They perform a wide variety of functions through interactions with each other and many additional molecules. Traditionally, proteins are described in a single static state (a picture). It is now increasingly recognised that many proteins can adopt multiple states and move between these conformational states dynamically (a movie).\n",
        "\n",
        "We investigate how the dynamics, conformational states and available experimental data of proteins relates to their amino acid sequence. Underlying physical and chemical principles are computationally unravelled through data integration, analysis and machine learning, so connecting them to biological events and improving our understanding of the way proteins work.\n",
        "\n",
        "Online predictors are available on https://bio2byte.be/b2btools/\n",
        "\n",
        "### Tools and predictors\n",
        "\n",
        "* **DynaMine** is a fast predictor of protein backbone dynamics using only sequence information as input. The version here also predicts side-chain dynamics and secondary structure predictors using the same principle. This tool returns the following predictions: \n",
        "  * DynaMine backbone dynamics\n",
        "  * DynaMine side chain dynamics\n",
        "  * DynaMine conformational propensities (polyproline II)\n",
        "  * DynaMine conformational propensities (coil)\n",
        "  * DynaMine conformational propensities (sheet)\n",
        "  * DynaMine conformational propensities (helix)\n",
        "\n",
        "* **EFoldMine** is a method that predicts from the primary amino acid sequence of a protein, which amino acids are likely involved in early folding events. This tool returns the following predictions:\n",
        "  * EFoldMine earlyFolding propensity\n",
        "\n",
        "* **DisoMine** method predicts protein disorder with recurrent neural networks not directly from the amino acid sequence, but instead from more generic predictions of key biophysical properties, here protein dynamics, secondary structure and early folding. This tool returns the following predictions:\n",
        "  * Disomine disorder\n",
        "\n",
        "* **AgMata** is a single-sequence based predictor of protein regions that are likely to cause beta-aggregation. This tool returns the following predictions:\n",
        "  * Agmata aggregation propensity"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r7PDo58NbYI3"
      },
      "source": [
        "## Requirements\n",
        "This section includes the commands to download the required libraries (from PyPi) and also the import sentences to use them in our toolkit."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "npGam_ciFvp7",
        "cellView": "form"
      },
      "source": [
        "#@title Install libraries from PyPi\n",
        "\n",
        "#@markdown Please execute this cell by pressing the _Play_ button \n",
        "\n",
        "from IPython.utils import io\n",
        "import tqdm.notebook\n",
        "\n",
        "TQDM_BAR_FORMAT = '{l_bar}{bar}| {n_fmt}/{total_fmt} [elapsed: {elapsed} remaining: {remaining}]'\n",
        "\n",
        "try:\n",
        "    with tqdm.notebook.tqdm(total=100, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
        "        with io.capture_output() as captured:\n",
        "          !pip uninstall --yes py3Dmol\n",
        "          pbar.update(15)\n",
        "          !pip install py3Dmol\n",
        "          pbar.update(18)\n",
        "          !pip uninstall --yes b2bTools\n",
        "          pbar.update(15)\n",
        "          !pip install b2bTools\n",
        "          pbar.update(18)\n",
        "          !pip uninstall --yes biopython\n",
        "          pbar.update(15)\n",
        "          !pip install biopython\n",
        "          pbar.update(19)\n",
        "except subprocess.CalledProcessError:\n",
        "    print(captured)\n",
        "    raise"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BP1Fix5WFoeO",
        "cellView": "form"
      },
      "source": [
        "#@title Import the required libraries\n",
        "\n",
        "#@markdown Please execute this cell by pressing the _Play_ button \n",
        "\n",
        "import py3Dmol\n",
        "import matplotlib.pyplot as plt\n",
        "import pickle\n",
        "import numpy as np\n",
        "from math import floor\n",
        "\n",
        "from IPython.display import display\n",
        "import ipywidgets as widgets\n",
        "from ipywidgets import GridspecLayout\n",
        "from ipywidgets import Output\n",
        "\n",
        "from b2bTools import SingleSeq\n",
        "from Bio import SeqIO \n",
        "from Bio.PDB import MMCIF2Dict"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ASnTZ-CDMJdE"
      },
      "source": [
        "## Source code\n",
        "This section contains the definition of all the functions that will be invoked afterwards during the analysis section."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GXyupYhyGJqP",
        "cellView": "form"
      },
      "source": [
        "#@title Define the file variables\n",
        "\n",
        "#@markdown Please execute this cell by pressing the _Play_ button \n",
        "\n",
        "fasta_file_path = ''\n",
        "pdb_file_path = ''\n",
        "pickle_file_path = ''\n",
        "cif_file_path = ''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SJg5lggiMIoX",
        "cellView": "form"
      },
      "source": [
        "#@title Define the constants\n",
        "\n",
        "#@markdown Please execute this cell by pressing the _Play_ button \n",
        "\n",
        "VALUES_CONSTANTS = {\n",
        "    \"pLDDT\": {\n",
        "        \"colors\": [\n",
        "            (0, 50, \"#FF7D45\"),\n",
        "            (50, 70, \"#FFDB13\"),\n",
        "            (70, 90, \"#65CBF3\"),\n",
        "            (90, 100, \"#0053D6\"),\n",
        "        ],\n",
        "        \"legends\": [\n",
        "            \"Very low (pLDDT < 50)\",\n",
        "            \"Low (50 < pLDDT < 70)\",\n",
        "            \"Confident (70 < pLDDT < 90)\",\n",
        "            \"Very high (pLDDT > 90)\",\n",
        "        ],\n",
        "        \"title\": \"AlphaFold's Model Confidence (pLDDT)\",\n",
        "    },\n",
        "    \"backbone\": {\n",
        "        \"colors\": [\n",
        "            (0, 0.69, \"#FF7D45\"),\n",
        "            (0.69, 0.80, \"#FFDB13\"),\n",
        "            (0.80, 1.00, \"#65CBF3\"),\n",
        "            (1.00, 2.00, \"#0053D6\"),\n",
        "        ],\n",
        "        \"legends\": [\n",
        "            \"Flexible region (value < 0.69)\",\n",
        "            \"Context dependent region (0.69 < value < 0.80)\",\n",
        "            \"Rigid region (0.80 < value < 1.00)\",\n",
        "            \"Membrane spanning region (value > 1.00)\",\n",
        "        ],\n",
        "        \"title\": \"DynaMine backbone dynamics\",\n",
        "    },\n",
        "    \"sidechain\": {\n",
        "        \"colors\": [\n",
        "            (0, 0.69, \"#FF7D45\"),\n",
        "            (0.69, 0.80, \"#FFDB13\"),\n",
        "            (0.80, 1.00, \"#65CBF3\"),\n",
        "            (1.00, 2.00, \"#0053D6\"),\n",
        "        ],\n",
        "        \"legends\": [\n",
        "            \"Flexible region (value < 0.69)\",\n",
        "            \"Context dependent region (0.69 < value < 0.80)\",\n",
        "            \"Rigid region (0.80 < value < 1.00)\",\n",
        "            \"Membrane spanning region (value > 1.00)\",\n",
        "        ],\n",
        "        \"title\": \"DynaMine sidechain dynamics\",\n",
        "    },\n",
        "    \"ppII\": {\n",
        "        \"colors\": [   \n",
        "            (0.00, 0.25, \"#ff0100\"),\n",
        "            (0.25, 0.50, \"#ffff00\"),\n",
        "            (0.50, 0.75, \"#7fff00\"),\n",
        "            (0.75, 1.00, \"#01ff00\"),\n",
        "        ],\n",
        "        \"legends\": [\n",
        "            \"Lowest propensity (value = 0.00)\",\n",
        "            \"Low propensity (0.00 < value < 0.25)\",\n",
        "            \"Mid propensity (0.25 < value < 0.50)\",\n",
        "            \"High propensity (0.50 < value < 0.75)\",\n",
        "            \"Very high propensity(0.75 < value < 1.00)\",\n",
        "        ],\n",
        "        \"title\": \"DynaMine conformational propensities (polyproline II)\",\n",
        "    },\n",
        "    \"coil\": {\n",
        "        \"colors\": [   \n",
        "            (0.00, 0.25, \"#ff0100\"),\n",
        "            (0.25, 0.50, \"#ffff00\"),\n",
        "            (0.50, 0.75, \"#7fff00\"),\n",
        "            (0.75, 1.00, \"#01ff00\"),\n",
        "        ],\n",
        "        \"legends\": [\n",
        "            \"Lowest propensity (value = 0.00)\",\n",
        "            \"Low propensity (0.00 < value < 0.25)\",\n",
        "            \"Mid propensity (0.25 < value < 0.50)\",\n",
        "            \"High propensity (0.50 < value < 0.75)\",\n",
        "            \"Very high propensity(0.75 < value < 1.00)\",\n",
        "        ],\n",
        "        \"title\": \"DynaMine conformational propensities (coil)\",\n",
        "    },\n",
        "    \"sheet\": {\n",
        "        \"colors\": [   \n",
        "            (0.00, 0.25, \"#ff0100\"),\n",
        "            (0.25, 0.50, \"#ffff00\"),\n",
        "            (0.50, 0.75, \"#7fff00\"),\n",
        "            (0.75, 1.00, \"#01ff00\"),\n",
        "        ],\n",
        "        \"legends\": [\n",
        "            \"Lowest propensity (value = 0.00)\",\n",
        "            \"Low propensity (0.00 < value < 0.25)\",\n",
        "            \"Mid propensity (0.25 < value < 0.50)\",\n",
        "            \"High propensity (0.50 < value < 0.75)\",\n",
        "            \"Very high propensity(0.75 < value < 1.00)\",\n",
        "        ],\n",
        "        \"title\": \"DynaMine conformational propensities (sheet)\",\n",
        "    },\n",
        "    \"helix\": {\n",
        "        \"colors\": [   \n",
        "            (0.00, 0.25, \"#ff0100\"),\n",
        "            (0.25, 0.50, \"#ffff00\"),\n",
        "            (0.50, 0.75, \"#7fff00\"),\n",
        "            (0.75, 1.00, \"#01ff00\"),\n",
        "        ],\n",
        "        \"legends\": [\n",
        "            \"Lowest propensity (value = 0.00)\",\n",
        "            \"Low propensity (0.00 < value < 0.25)\",\n",
        "            \"Mid propensity (0.25 < value < 0.50)\",\n",
        "            \"High propensity (0.50 < value < 0.75)\",\n",
        "            \"Very high propensity(0.75 < value < 1.00)\",\n",
        "        ],\n",
        "        \"title\": \"DynaMine conformational propensities (helix)\",\n",
        "        \"subtitle\": \"DynaMine is a fast predictor of protein backbone dynamics using only sequence information as input. The version here also predicts side-chain dynamics and secondary structure predictors using the same principle.\",\n",
        "    },\n",
        "    \"earlyFolding\": {\n",
        "        \"colors\": [\n",
        "            (0, 0.169, \"#FF7D45\"),\n",
        "            (0.169 ,2, \"#0053D6\"),\n",
        "        ],\n",
        "        \"legends\": [\n",
        "            \"Not likely to start the protein folding process (value < 0.169)\",\n",
        "            \"Likely to start the protein folding process (value > 0.169)\",\n",
        "        ],\n",
        "        \"title\": \"EFoldMine earlyFolding propensity\",\n",
        "    },\n",
        "    \"disoMine\": {\n",
        "        \"colors\": [\n",
        "            (0, 0.50, \"#FF7D45\"),\n",
        "            (0.50, 1.00, \"#0053D6\"),\n",
        "        ],\n",
        "        \"legends\": [\n",
        "            \"Not likely a disordered residue (value < 0.50)\",\n",
        "            \"Likely a disordered residue (value > 0.50)\",\n",
        "        ],\n",
        "        \"title\": \"Disomine disorder\",\n",
        "    },\n",
        "    \"agmata\": {\n",
        "        \"colors\": [\n",
        "            (0.00, 0.25, \"#ff0100\"),\n",
        "            (0.50, 0.75, \"#ffff00\"),\n",
        "            (0.75, 1.00, \"#01ff00\"),\n",
        "        ],\n",
        "        \"legends\": [\n",
        "            \"Not likely to be involved in beta-sheet aggregation (Trough)\",\n",
        "            \"Likely to be involved in beta-sheet aggregation (Mid Peak)\",\n",
        "            \"Most likely to be involved in beta-sheet aggregation (Higher Peak)\",\n",
        "        ],\n",
        "        \"title\": \"Agmata aggregation propensity\",\n",
        "    },\n",
        "}\n",
        "\n",
        "B2B_TOOLS = [\"dynamine\", \"disomine\", \"efoldmine\", \"agmata\"]\n",
        "\n",
        "B2B_TOOLS_RESULTS = np.array(\n",
        "    [\n",
        "        [\"backbone\", \"sidechain\", \"ppII\"],\n",
        "        [\"coil\", \"sheet\", \"helix\"],\n",
        "        [\"earlyFolding\", \"disoMine\", \"agmata\"],\n",
        "    ]\n",
        ")\n",
        "\n",
        "PLDDT_COLOR_MAP = {i: bands[2] for i, bands in enumerate(VALUES_CONSTANTS[\"pLDDT\"][\"colors\"])}\n",
        "PLDDT_DEFAULT_ATOM_STYLE = {\"cartoon\": {\"colorscheme\": {\"prop\": \"b\", \"map\": PLDDT_COLOR_MAP}}}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fjxy6_SELP5e",
        "cellView": "form"
      },
      "source": [
        "#@title Define the classes\n",
        "\n",
        "#@markdown Please execute this cell by pressing the _Play_ button \n",
        "\n",
        "class Atom(dict):\n",
        "    def __init__(self, line):\n",
        "        self[\"type\"] = line[0:6].strip()\n",
        "        self[\"idx\"] = line[6:11].strip()\n",
        "        self[\"name\"] = line[12:16].strip()\n",
        "        self[\"resname\"] = line[17:20].strip()\n",
        "        self[\"resid\"] = int(int(line[22:26]))\n",
        "        self[\"x\"] = float(line[30:38])\n",
        "        self[\"y\"] = float(line[38:46])\n",
        "        self[\"z\"] = float(line[46:54])\n",
        "        self[\"sym\"] = line[76:78].strip()\n",
        "\n",
        "    def __str__(self):\n",
        "        line = list(\" \" * 80)\n",
        "\n",
        "        line[0:6] = self[\"type\"].ljust(6)\n",
        "        line[6:11] = self[\"idx\"].ljust(5)\n",
        "        line[12:16] = self[\"name\"].ljust(4)\n",
        "        line[17:20] = self[\"resname\"].ljust(3)\n",
        "        line[22:26] = str(self[\"resid\"]).ljust(4)\n",
        "        line[30:38] = str(self[\"x\"]).rjust(8)\n",
        "        line[38:46] = str(self[\"y\"]).rjust(8)\n",
        "        line[46:54] = str(self[\"z\"]).rjust(8)\n",
        "        line[76:78] = self[\"sym\"].rjust(2)\n",
        "        return \"\".join(line) + \"\\n\"\n",
        "\n",
        "\n",
        "class Molecule(list):\n",
        "    def __init__(self, file):\n",
        "        for line in file:\n",
        "            if \"ATOM\" in line or \"HETATM\" in line:\n",
        "                self.append(Atom(line))\n",
        "\n",
        "    def __str__(self):\n",
        "        outstr = \"\"\n",
        "        for at in self:\n",
        "            outstr += str(at)\n",
        "\n",
        "        return outstr"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ObPH6r1Qzu1R",
        "cellView": "form"
      },
      "source": [
        "#@title Declare the methods required to analyze the sequences\n",
        "\n",
        "#@markdown Please execute this cell by pressing the _Play_ button \n",
        "\n",
        "import tqdm.notebook\n",
        "\n",
        "TQDM_BAR_FORMAT = '{l_bar}{bar}| {n_fmt}/{total_fmt} [elapsed: {elapsed} remaining: {remaining}]'\n",
        "\n",
        "def analyze_sequence(plddt, b2b_predictions_results):\n",
        "    with tqdm.notebook.tqdm(total=100, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
        "        fig, axs = plt.subplots(\n",
        "            B2B_TOOLS_RESULTS.shape[0], \n",
        "            B2B_TOOLS_RESULTS.shape[1], \n",
        "            sharex=False, \n",
        "            sharey=False\n",
        "        )\n",
        "        fig.set_size_inches(18, 10)\n",
        "        fig.legend(\n",
        "            VALUES_CONSTANTS[\"pLDDT\"][\"legends\"], \n",
        "            frameon=False, \n",
        "            loc=\"center\", \n",
        "            fontsize=20\n",
        "        )\n",
        "        pbar.update(10)\n",
        "\n",
        "        predictors_count = B2B_TOOLS_RESULTS.shape[0] * B2B_TOOLS_RESULTS.shape[1]\n",
        "        for ix, iy in np.ndindex(B2B_TOOLS_RESULTS.shape):\n",
        "            result_key = B2B_TOOLS_RESULTS[ix, iy]\n",
        "\n",
        "            axs[ix, iy].plot(\n",
        "                b2b_predictions_results[result_key], \n",
        "                \"tab:blue\", \n",
        "                label=result_key\n",
        "            )\n",
        "            axs[ix, iy].set_ylabel(\"{0} (blue)\".format(result_key))\n",
        "            if not result_key == \"agmata\":\n",
        "                axs[ix, iy].set_ylim([0, 1.20])\n",
        "\n",
        "            pLDDT_axis = axs[ix, iy].twinx()\n",
        "            pLDDT_axis.plot(plddt, \"tab:red\", label=\"pLDDT\")\n",
        "            pLDDT_axis.set_ylabel(\"pLDDT (red)\")\n",
        "            pLDDT_axis.set_ylim([0, 120])\n",
        "            \n",
        "            axs[ix, iy].set_title(\"{0} vs pLDDT\".format(result_key))\n",
        "            axs[ix, iy].set_xlabel(\"Residue position\")\n",
        "            pbar.update(90/predictors_count)\n",
        "\n",
        "        fig.tight_layout()\n",
        "        fig.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OrzE6TSr0erI",
        "cellView": "form"
      },
      "source": [
        "#@title Declare the methods required to plot the 3D structures\n",
        "\n",
        "#@markdown Please execute this cell by pressing the _Play_ button \n",
        "\n",
        "import tqdm.notebook\n",
        "\n",
        "TQDM_BAR_FORMAT = '{l_bar}{bar}| {n_fmt}/{total_fmt} [elapsed: {elapsed} remaining: {remaining}]'\n",
        "\n",
        "def get_value_color(result_key, value, min_value=0, max_value=1):\n",
        "    if (result_key == \"ppII\" \n",
        "        or result_key == \"coil\" \n",
        "        or result_key == \"sheet\" \n",
        "        or result_key == \"helix\" \n",
        "        or result_key == \"agmata\"):\n",
        "        return get_spectrum_color(value, min_value, max_value)\n",
        "    else:\n",
        "        for band in VALUES_CONSTANTS[result_key][\"colors\"]:\n",
        "            band_floor, band_ceiling, band_color = band\n",
        "            if value > band_floor and value <= band_ceiling:\n",
        "                return band_color\n",
        "\n",
        "def get_spectrum_color(real, min_value, max_value):\n",
        "    color_r = 0\n",
        "    color_g = 0\n",
        "    color_b = 0\n",
        "\n",
        "    value = real\n",
        "    base = max_value - min_value\n",
        "    if (value < min_value):\n",
        "        value = min_value \n",
        "    elif value > max_value:\n",
        "        value = max_value\n",
        "\n",
        "    if base == 0:\n",
        "        value = 100\n",
        "    else:\n",
        "        value = (value - min_value) / base * 100\n",
        "    \n",
        "    if value < 50:\n",
        "        color_r = 255\n",
        "        off_g = 5.1 * value\n",
        "        color_g = max(1, off_g)\n",
        "    else:\n",
        "        color_g = 255\n",
        "        off_r = 510 - 5.1 * value\n",
        "        color_r = max(1, off_r)\n",
        "  \n",
        "    return '#%02x%02x%02x' % (int(color_r), int(color_g), int(color_b))\n",
        "\n",
        "def create_py3dmol_view(molecule, color_key):\n",
        "    view = py3Dmol.view(width=400, height=300)\n",
        "    view.setBackgroundColor(\"white\")\n",
        "    view.addModelsAsFrames(str(molecule))\n",
        "\n",
        "    default_color_style = {\"cartoon\": {\"color\": \"black\"}}\n",
        "    for atom_index, atom in enumerate(molecule):\n",
        "        view.setStyle(\n",
        "            {\"model\": -1, \"serial\": atom_index + 1}, \n",
        "            atom.get(color_key, default_color_style)\n",
        "        )\n",
        "\n",
        "    view.zoomTo()\n",
        "    return view\n",
        "\n",
        "\n",
        "def plot_result_legend(result_key):\n",
        "    \"\"\"Plots the legend for a predicted result.\"\"\"\n",
        "\n",
        "    value_constants = VALUES_CONSTANTS[result_key]\n",
        "    colors = [x[2] for x in value_constants[\"colors\"]]\n",
        "\n",
        "    plt.figure(figsize=(2, 2))\n",
        "    for c in colors:\n",
        "        plt.bar(0, 0, color=c)\n",
        "\n",
        "    plt.legend(value_constants[\"legends\"], frameon=False, loc=\"center\", fontsize=14)\n",
        "    plt.xticks([])\n",
        "    plt.yticks([])\n",
        "    ax = plt.gca()\n",
        "    ax.spines[\"right\"].set_visible(False)\n",
        "    ax.spines[\"top\"].set_visible(False)\n",
        "    ax.spines[\"left\"].set_visible(False)\n",
        "    ax.spines[\"bottom\"].set_visible(False)\n",
        "    # plt.suptitle(value_constants[\"title\"], fontsize=18)\n",
        "    plt.title(value_constants[\"title\"], fontsize=16, pad=16)\n",
        "\n",
        "    return plt\n",
        "\n",
        "def plot_structure(pdb_file, plddt, b2b_predictions_results):\n",
        "    with tqdm.notebook.tqdm(total=100, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
        "        b2b_agmata_result = b2b_predictions_results['agmata']\n",
        "        agmata_min_value = min(b2b_agmata_result)\n",
        "        agmata_max_value = max(b2b_agmata_result)\n",
        "\n",
        "        pbar.update(2.5)\n",
        "\n",
        "        with open(pdb_file, \"r\") as ifile:\n",
        "            molecule = Molecule(ifile)\n",
        "    \n",
        "        for atom in molecule:\n",
        "            res_id = int(atom[\"resid\"]) - 1\n",
        "            for result_key in VALUES_CONSTANTS.keys():\n",
        "                if result_key == \"pLDDT\":\n",
        "                    atom[result_key] = plddt[res_id]\n",
        "                else:\n",
        "                    atom[result_key] = b2b_predictions_results[result_key][res_id]\n",
        "\n",
        "                if result_key == \"agmata\":\n",
        "                    atom_color = get_value_color(\n",
        "                        result_key, \n",
        "                        atom[result_key], \n",
        "                        min_value=agmata_min_value, \n",
        "                        max_value=agmata_max_value\n",
        "                    )\n",
        "                else:\n",
        "                    atom_color = get_value_color(result_key, atom[result_key])\n",
        "\n",
        "                atom[\"{0}_color\".format(result_key)] = {\n",
        "                    \"cartoon\": {\n",
        "                        \"color\": atom_color\n",
        "                      }\n",
        "                }\n",
        "        \n",
        "        pbar.update(2.5)\n",
        "        grid = GridspecLayout(len(np.matrix.flatten(B2B_TOOLS_RESULTS)) + 1, 2)\n",
        "\n",
        "        output_plot = Output()\n",
        "        with output_plot:\n",
        "            create_py3dmol_view(molecule, \"pLDDT_color\").show()\n",
        "        grid[0, 0] = output_plot\n",
        "\n",
        "        output_legend = Output()\n",
        "        with output_legend:\n",
        "            plot_result_legend(\"pLDDT\").show()\n",
        "        grid[0, 1] = output_legend\n",
        "        pbar.update(5)\n",
        "\n",
        "        predictors_count = B2B_TOOLS_RESULTS.shape[0] * B2B_TOOLS_RESULTS.shape[1]\n",
        "        for index, result_key in enumerate(np.matrix.flatten(B2B_TOOLS_RESULTS)):\n",
        "            output_plot = Output()\n",
        "            with output_plot:\n",
        "                create_py3dmol_view(\n",
        "                    molecule, \n",
        "                    \"{0}_color\".format(result_key)\n",
        "                ).show()\n",
        "\n",
        "            grid[index + 1, 0] = output_plot\n",
        "\n",
        "            output_legend = Output()\n",
        "            with output_legend:\n",
        "                plot_result_legend(result_key).show()\n",
        "\n",
        "            grid[index + 1, 1] = output_legend\n",
        "            pbar.update(90 / predictors_count)\n",
        "\n",
        "        display(grid)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dfYItux8Ge41"
      },
      "source": [
        "## Files input\n",
        "Please upload the sequence in FASTA format, the structure in PDB format and the AlphaFold results in either Pickle format or CIF."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KTMVntGrFN7C"
      },
      "source": [
        "#@title Upload Fasta { display-mode: \"form\" }\n",
        "\n",
        "#@markdown Please execute this cell by pressing the _Play_ button and upload just one FASTA file\n",
        "\n",
        "from google.colab import files\n",
        "from os import path\n",
        "\n",
        "fasta_uploaded = files.upload()\n",
        "print(fasta_uploaded.keys())\n",
        "\n",
        "for fasta_file_name in fasta_uploaded.keys():\n",
        "  fasta_file_path = path.join('/content/', fasta_file_name)\n",
        "\n",
        "  print('User fasta_uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "      name=fasta_file_path, length=len(fasta_uploaded[fasta_file_name])))\n",
        "\n",
        "sequence_keys = []\n",
        "fasta = SeqIO.parse(open(fasta_file_path), \"fasta\")\n",
        "for sequence in fasta:\n",
        "  sequence_keys.append(sequence.id)\n",
        "\n",
        "sequence_picker = widgets.Dropdown(options=sequence_keys, description=\"Sequence:\")\n",
        "display(sequence_picker)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K0JuN-1cI9gz"
      },
      "source": [
        "selected_sequence = sequence_picker.value\n",
        "print(\"Selected sequence:\", selected_sequence)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ofYp_3NwKzw3"
      },
      "source": [
        "#@title Upload PDB { display-mode: \"form\" }\n",
        "#@markdown Please execute this cell by pressing the _Play_ button and upload just one PDB file\n",
        "\n",
        "from google.colab import files\n",
        "from os import path\n",
        "\n",
        "pdb_uploaded = files.upload()\n",
        "\n",
        "for pdb_file_name in pdb_uploaded.keys():\n",
        "  pdb_file_path = path.join(\"/content/\", pdb_file_name)\n",
        "\n",
        "  print('User pdb_uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "      name=pdb_file_path, length=len(pdb_uploaded[pdb_file_name])))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QnmEe1ckJQhw"
      },
      "source": [
        "#@title Upload PKL { display-mode: \"form\" }\n",
        "#@markdown Please execute this cell by pressing the _Play_ button and upload just one Pickle file\n",
        "from google.colab import files\n",
        "from os import path\n",
        "\n",
        "pkl_uploaded = files.upload()\n",
        "\n",
        "for pickle_file_name in pkl_uploaded.keys():\n",
        "  pickle_file_path = path.join(\"/content/\", pickle_file_name)\n",
        "\n",
        "  print('User pkl_uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "      name=pickle_file_path, length=len(pkl_uploaded[pickle_file_name])))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Iq6M3EQaEg_K"
      },
      "source": [
        "#@title Upload mmCIF { display-mode: \"form\" }\n",
        "#@markdown Please execute this cell by pressing the _Play_ button and upload a mmCIF file instead the PKL\n",
        "from google.colab import files\n",
        "from os import path\n",
        "\n",
        "cif_uploaded = files.upload()\n",
        "\n",
        "for cif_file_name in cif_uploaded.keys():\n",
        "  cif_file_path = path.join(\"/content/\", cif_file_name)\n",
        "\n",
        "  print('User cif_uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "      name=cif_file_path, length=len(cif_uploaded[cif_file_name])))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U-g4AFJiMQ2V"
      },
      "source": [
        "\n",
        "## Analysis\n",
        "This section invokes the previous defined functions to analyze the information provided by AlphaFold. It includes pLDDT vs different Bio2Byte tools and the three-dimensional plot of the predicted structure colored using different values. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GtyblyAJ8Zoa"
      },
      "source": [
        "print(pickle_file_path)\n",
        "print(cif_file_path)\n",
        "\n",
        "fasta = SeqIO.parse(open(fasta_file_path), \"fasta\")\n",
        "for r in fasta.records:\n",
        "  print(len(r.seq), r.seq)\n",
        "\n",
        "if pickle_file_path != '':\n",
        "    with open(pickle_file_path, \"rb\") as dbfile:\n",
        "        db = pickle.load(dbfile)\n",
        "    plddt = np.array(db[\"plddt\"])\n",
        "elif cif_file_path != '':\n",
        "    cif_dictionary = MMCIF2Dict.MMCIF2Dict(cif_file_path)\n",
        "    plddt = map(lambda v: float(v), cif_dictionary.get('_ma_qa_metric_local.metric_value'))\n",
        "    plddt = list(plddt)\n",
        "else:\n",
        "    raise FileNotFoundError(\"pLDDT data is not available, please upload a PKL or mmCIF file and try running this cell again\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1ubS4yVEOQa6"
      },
      "source": [
        "#@title Run B2B Tools { display-mode: \"form\" }\n",
        "#@markdown Please execute this cell by pressing the _Play_ button and upload just one PDB file\n",
        "\n",
        "from IPython.utils import io\n",
        "import tqdm.notebook\n",
        "\n",
        "TQDM_BAR_FORMAT = '{l_bar}{bar}| {n_fmt}/{total_fmt} [elapsed: {elapsed} remaining: {remaining}]'\n",
        "\n",
        "try:\n",
        "    with tqdm.notebook.tqdm(total=100, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
        "        with io.capture_output() as captured:\n",
        "            single_seq = SingleSeq(fasta_file_path)\n",
        "            pbar.update(25)\n",
        "            single_seq.predict(tools=B2B_TOOLS)\n",
        "            pbar.update(50)\n",
        "            b2b_predictions_results = single_seq.get_all_predictions()[selected_sequence]\n",
        "            pbar.update(25)\n",
        "except subprocess.CalledProcessError:\n",
        "    print(captured)\n",
        "    raise"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gzSWd-PxLoJZ"
      },
      "source": [
        "#@title Plot predictions vs pLDDT { display-mode: \"form\" }\n",
        "#@markdown Please execute this cell by pressing the _Play_ button. \n",
        "\n",
        "#@markdown Blue series represents the Bio2Byte predictions and red one is the pLDDT value. \n",
        "\n",
        "#@markdown **About pLDDT**:\n",
        "#@markdown > AlphaFold produces a per-residue confidence score (pLDDT) between 0 and 100. Some regions below 50 pLDDT may be unstructured in isolation.\n",
        "analyze_sequence(plddt, b2b_predictions_results)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "49zUtSnKLyrV"
      },
      "source": [
        "#@title Render three-dimensional structures { display-mode: \"form\" }\n",
        "#@markdown Please execute this cell by pressing the _Play_ button\n",
        "\n",
        "plot_structure(pdb_file_path, plddt, b2b_predictions_results)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KI1v2KsXlBNK"
      },
      "source": [
        "## Conclusion and notes\n",
        "\n",
        "**Important note:** If you need to run these analysis again, please restart the Runtime from the menu \"Runtime\"\n",
        "\n",
        "Download the Bio2Byte's tools package from our PyPi repository: https://pypi.org/project/b2bTools/.\n",
        "\n",
        "### Citations\n",
        "\n",
        "DynaMine:\n",
        "> Elisa Cilia, Rita Pancsa, Peter Tompa, Tom Lenaerts, and Wim Vranken From protein sequence to dynamics and disorder with DynaMine Nature Communications 4:2741(2013)\n",
        "doi: 10.1038/ncomms3741\n",
        "\n",
        "EFoldMine:\n",
        "> Raimondi, D., Orlando, G., Pancsa, R. et al. Exploring the Sequence-based Prediction of Folding Initiation Sites in Proteins. Sci Rep 7, 8826 (2017).\n",
        "doi: https://doi.org/10.1038/s41598-017-08366-3\n",
        "\n",
        "Disomine:\n",
        "> Gabriele Orlando, Daniele Raimondi, Francesco Codice, Francesco Tabaro, Wim Vranken bioRxiv 2020.05.25.115253;\n",
        "doi: https://doi.org/10.1101/2020.05.25.115253\n",
        "\n",
        "AgMata:\n",
        "> O.G, S.A, MR.S, R.D, V.W.; Accurate prediction of protein beta-aggregation with generalized statistical potentials. doi: 10.1093/bioinformatics/btz912.\n",
        "\n",
        "Regarding AlphaFold:\n",
        "```\n",
        "@Article{AlphaFold2021,\n",
        "  author  = {Jumper, John and Evans, Richard and Pritzel, Alexander and Green, Tim and Figurnov, Michael and Ronneberger, Olaf and Tunyasuvunakool, Kathryn and Bates, Russ and {\\v{Z}}{\\'\\i}dek, Augustin and Potapenko, Anna and Bridgland, Alex and Meyer, Clemens and Kohl, Simon A A and Ballard, Andrew J and Cowie, Andrew and Romera-Paredes, Bernardino and Nikolov, Stanislav and Jain, Rishub and Adler, Jonas and Back, Trevor and Petersen, Stig and Reiman, David and Clancy, Ellen and Zielinski, Michal and Steinegger, Martin and Pacholska, Michalina and Berghammer, Tamas and Bodenstein, Sebastian and Silver, David and Vinyals, Oriol and Senior, Andrew W and Kavukcuoglu, Koray and Kohli, Pushmeet and Hassabis, Demis},\n",
        "  journal = {Nature},\n",
        "  title   = {Highly accurate protein structure prediction with {AlphaFold}},\n",
        "  year    = {2021},\n",
        "  doi     = {10.1038/s41586-021-03819-2},\n",
        "  note    = {(Accelerated article preview)},\n",
        "}\n",
        "```"
      ]
    }
  ]
}