Scop3P_O00571_4PXA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3a5dd7d4-467d-4aba-9355-04b482638ea7",
   "metadata": {},
   "source": [
    "# Scop3P\n",
    "\n",
    "A comprehensive database of human phosphosites within their full context. Scop3P integrates sequences (UniProtKB/Swiss-Prot), structures (PDB), and uniformly reprocessed phosphoproteomics data (PRIDE) to annotate all known human phosphosites. \n",
    "\n",
    "Scop3P, available at https://iomics.ugent.be/scop3p, presents a unique resource for visualization and analysis of phosphosites and for understanding of phosphosite structure–function relationships."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bb1e9ff-c789-4c96-b71d-5da2af53b437",
   "metadata": {},
   "source": [
    "## Install Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ba367321-b7ac-44b9-98c0-c800fd1ae008",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "!jupyter labextension install jupyterlab_3dmol\n",
    "!pip install pandas matplotlib py3Dmol b2btools==3.0.7b2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "62a30299-1084-4700-a8ed-64f77b68c0c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "import requests, tempfile,json\n",
    "import pandas as pd \n",
    "from b2bTools import SingleSeq, constants\n",
    "import py3Dmol"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2dc9e1f-97d2-45a8-a21a-b7258664d265",
   "metadata": {},
   "source": [
    "## Target protein"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bd5e0bc6-c9ee-485f-9a7c-3adc53f7cd66",
   "metadata": {},
   "outputs": [],
   "source": [
    "TARGET_PROTEIN_ID = \"O00571\" # Write here the Protein ID of your protein of interest\n",
    "PDB_ID = \"4PXA\" # Write here the PDB ID of your protein of interest"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e622d9b-1922-4851-ab6b-41ae0d62c395",
   "metadata": {},
   "source": [
    "## API Request\n",
    "\n",
    "This function makes a GET request to Scop3P API endpoint for a given protein accession ID and returns the protein sequence in string format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "87d604d4-ba1a-4acb-94b7-0481abe40fac",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fetch_protein_modifications(accession):\n",
    "    \"\"\"\n",
    "    Fetches protein modifications for a given UniProt ID.\n",
    "\n",
    "    Parameters:\n",
    "    accession (str): UniProt ID of the protein.\n",
    "\n",
    "    Returns:\n",
    "    dict: A dictionary containing protein modifications.\n",
    "    \"\"\"\n",
    "    BASE_URL = \"https://iomics.ugent.be/scop3p/api/modifications\"\n",
    "    url = f'{BASE_URL}?accession={accession}'\n",
    "    headers = {'accept': 'application/json'}\n",
    "    response = requests.get(url, headers=headers)\n",
    "    if response.status_code == 200:\n",
    "        return response.json()\n",
    "    else:\n",
    "        return None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c09ac2da-0a01-4b83-97ba-96c9fa9fb598",
   "metadata": {},
   "source": [
    "## Data parsing\n",
    "\n",
    "For parsing the JSON as a table, we'll use pandas library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fdd2c83a-bbdf-4ccd-993f-92078980fd9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "scop3P_results = fetch_protein_modifications(TARGET_PROTEIN_ID)\n",
    "\n",
    "protein_name = scop3P_results['proteinName']\n",
    "entry_name = scop3P_results['entryName']\n",
    "accession = scop3P_results['accession']\n",
    "url = scop3P_results['url']\n",
    "modifications = scop3P_results['modifications']\n",
    "\n",
    "print(\"\"\"\n",
    "--------------------------------------------------------------------------------\n",
    "Scop3P: A Comprehensive Resource of Human Phosphosites within Their Full Context\n",
    "--------------------------------------------------------------------------------\n",
    "\n",
    "{0}:{1}\n",
    "\n",
    "Phospho-sites found: {3} entries.\n",
    "\n",
    "Full entry available on SCOP3P website: {2}\n",
    "\"\"\".format(entry_name, protein_name, url, len(modifications)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "51c73c52-5955-45d9-9d9d-fa3fe6069bfb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_modification_table(modifications):\n",
    "    \"\"\"\n",
    "    Displays the protein modifications in a pandas DataFrame.\n",
    "\n",
    "    Parameters:\n",
    "    modifications (list): A list of dictionaries, each representing a protein modification.\n",
    "    \"\"\"\n",
    "    df = pd.DataFrame(modifications)\n",
    "    df = df[['residue', 'name', 'evidence', 'position', 'source', 'reference', 'functionalScore', 'specificSinglyPhosphorylated']]\n",
    "    \n",
    "    return df \n",
    "    \n",
    "modification_table = get_modification_table(modifications)\n",
    "display(modification_table)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07038b8d-ba1e-4f2e-9c60-74e1b353937e",
   "metadata": {},
   "source": [
    "## Rendering results\n",
    "\n",
    "For visualizing the 3D structure, we'll use py3Dmol library."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9702c23f",
   "metadata": {},
   "source": [
    "## Let's get AlphaFold model for the target protein\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6192377b",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Get alphaFold model for the protein\n",
    "import urllib.request\n",
    "AFurl=\"https://alphafold.ebi.ac.uk/files/AF-\"\n",
    "modelurl = f'{AFurl}{accession}{\"-F1-model_v4.pdb\"}'\n",
    "AFmodel = urllib.request.urlretrieve(modelurl,f'{accession}{\".pdb\"}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41b5d7c5",
   "metadata": {},
   "source": [
    "## Rendering results\n",
    "\n",
    "For visualizing the 3D structure, we'll use py3Dmol library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "157e10c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def display_3D(modification_table):\n",
    "    view = py3Dmol.view()\n",
    "    view.addModel(open((accession+'.pdb'), 'r').read(),'pdb')\n",
    "    \n",
    "    view.setStyle({'cartoon': { 'color': 'silver' }})\n",
    "    view.addSurface(py3Dmol.VDW, {'opacity': 0.60, 'color': 'white' })\n",
    "    \n",
    "    for index, row in modification_table.iterrows():\n",
    "        position = row['position']\n",
    "        residue = row['residue']\n",
    "        if residue == 'PhosphoY':\n",
    "            color = '#2CA02C'\n",
    "        elif residue == 'PhosphoS':\n",
    "            color = '#1F77B4'\n",
    "        elif residue == 'PhosphoT':\n",
    "            color = '#FF7F0E'\n",
    "        else:\n",
    "            color = '#7B241C'\n",
    "        view.addSurface(py3Dmol.VDW, {'opacity': 1.0, 'color': color }, {'resi': [str(position)]})\n",
    "        view.setHoverable(\n",
    "            {},\n",
    "            True,\n",
    "            \"\"\"\n",
    "            function(atom, viewer, event, container) {{\n",
    "                if (!atom.label) {{\n",
    "                    atom.label = viewer.addLabel(\n",
    "                        \"{0} \" + atom.resn + {1}, {{ 'position': atom, backgroundColor: 'mintcream', fontColor:'black' }}\n",
    "                    );\n",
    "                }}\n",
    "            }}\n",
    "            \"\"\".format(residue, position),\n",
    "            \"\"\"\n",
    "            function(atom,viewer) {\n",
    "                if(atom.label) {\n",
    "                    viewer.removeLabel(atom.label);\n",
    "                    delete atom.label;\n",
    "                }\n",
    "            }\n",
    "            \"\"\"\n",
    "        )\n",
    "    \n",
    "    view.zoomTo()\n",
    "    return view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "83b2f132",
   "metadata": {},
   "outputs": [],
   "source": [
    "display_3D(modification_table)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bde07233",
   "metadata": {},
   "source": [
    "### PDB structure mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e15fc47d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def display_3D(modification_table):\n",
    "    view = py3Dmol.view(query=f'pdb:{PDB_ID}')\n",
    "    \n",
    "    view.setStyle({'cartoon': { 'color': 'skyblue' }})\n",
    "    view.addSurface(py3Dmol.VDW, {'opacity': 0.60, 'color': 'white' })\n",
    "    \n",
    "    for index, row in modification_table.iterrows():\n",
    "        position = row['position']\n",
    "        residue = row['residue']\n",
    "        \n",
    "        if residue == 'PhosphoY':\n",
    "            color = '#2CA02C'\n",
    "        elif residue == 'PhosphoS':\n",
    "            color = '#1F77B4'\n",
    "        elif residue == 'PhosphoT':\n",
    "            color = '#FF7F0E'\n",
    "        else:\n",
    "            color = '#7B241C'\n",
    "        \n",
    "        view.addSurface(py3Dmol.VDW, {'opacity': 1.0, 'color': color }, {'resi': [str(position)]})\n",
    "        view.setHoverable(\n",
    "            {},\n",
    "            True,\n",
    "            \"\"\"\n",
    "            function(atom, viewer, event, container) {{\n",
    "                if (!atom.label) {{\n",
    "                    atom.label = viewer.addLabel(\n",
    "                        \"{0} \" + atom.resn + {1}, {{ 'position': atom, backgroundColor: 'mintcream', fontColor:'black' }}\n",
    "                    );\n",
    "                }}\n",
    "            }}\n",
    "            \"\"\".format(residue, position),\n",
    "            \"\"\"\n",
    "            function(atom,viewer) {\n",
    "                if(atom.label) {\n",
    "                    viewer.removeLabel(atom.label);\n",
    "                    delete atom.label;\n",
    "                }\n",
    "            }\n",
    "            \"\"\"\n",
    "        )\n",
    "    \n",
    "    view.zoomTo()\n",
    "    return view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "695e2f23",
   "metadata": {},
   "outputs": [],
   "source": [
    "display_3D(modification_table)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3673c56",
   "metadata": {},
   "source": [
    "## Mapping Biophysical properties on AF models\n",
    "\n",
    "For visualizing the 3D structure, we'll use py3Dmol library."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b2b826c",
   "metadata": {},
   "source": [
    "### Predict dynamic properties from Bio2Byte tools\n",
    "\n",
    "We will fetch the amino acid sequence from UniProtKB API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "054287d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fetch_sequence_aminoacids(accession):\n",
    "    BASE_URL = f\"http://uniprot.org/uniprotkb/{accession}.fasta\"\n",
    "    url = f'{BASE_URL}?accession={accession}'\n",
    "    response = requests.get(url)\n",
    "    if response.status_code == 200:\n",
    "        raw_fasta_sequence = response.content.decode(\"utf-8\")\n",
    "    else:\n",
    "        raw_fasta_sequence = \"\"\n",
    "    \n",
    "    lines = raw_fasta_sequence.split('\\n')\n",
    "    protein_id = str(lines[0])\n",
    "    amino_acids = \"\".join([str(l) for l in lines[1:]])\n",
    "    \n",
    "    return protein_id, amino_acids"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "571a92ad",
   "metadata": {},
   "source": [
    "#### Predict Dynamic properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8c75dda7",
   "metadata": {},
   "outputs": [],
   "source": [
    "_protein_id, sequence = fetch_sequence_aminoacids(TARGET_PROTEIN_ID)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a1beaf87",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "def predict_biophysical_features(accession, sequence):\n",
    "\n",
    "    with tempfile.NamedTemporaryFile(prefix=\"seq_\", suffix=\".fasta\", mode=\"w\") as fp:\n",
    "        fp.write(f\">{accession}\\n{sequence}\\n\")\n",
    "        fp.flush()\n",
    "        fp.seek(0)\n",
    "        \n",
    "        pred = SingleSeq(fp.name).predict(tools=[constants.TOOL_DYNAMINE, constants.TOOL_DISOMINE, constants.TOOL_EFOLDMINE]).get_all_predictions()\n",
    "    \n",
    "    return pred\n",
    "\n",
    "\n",
    "biophysical_features = predict_biophysical_features(TARGET_PROTEIN_ID, sequence)\n",
    "\n",
    "biophysical_features_target_protein = biophysical_features['proteins'][TARGET_PROTEIN_ID]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "af0814fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# values above 1.0 membrane spanning regions, \n",
    "# Values above 0.8 indicate rigid conformations, \n",
    "# Values between 0.69-0.80 are 'context' dependent and capable of being either rigid or flexible.\n",
    "# values below 0.69 flexible regions. \n",
    "\n",
    "# phosphorylated = list(modifications_table['position'])\n",
    "biophysical_features_target_protein['BD_label'] = []\n",
    "biophysical_features_target_protein['DO_label'] = []\n",
    "biophysical_features_target_protein['EF_label'] = []\n",
    "# biophysical_features_target_protein['psites'] = []\n",
    "\n",
    "for index, residue in enumerate(biophysical_features_target_protein['seq']):\n",
    "    current_backbone = biophysical_features_target_protein['backbone'][index]\n",
    "    biophysical_features_target_protein['BD_label'].append(1 if current_backbone > 1 else 2 if current_backbone > 0.8 else 3 if current_backbone > 0.69 else 4)\n",
    "\n",
    "    current_disorder_propensity = biophysical_features_target_protein['disoMine'][index]\n",
    "    biophysical_features_target_protein['DO_label'].append(1 if current_disorder_propensity > 0.5 else 0)\n",
    "\n",
    "    current_early_folding = biophysical_features_target_protein['earlyFolding'][index]\n",
    "    biophysical_features_target_protein['EF_label'].append(1 if current_early_folding > 0.169 else 0)\n",
    "    \n",
    "#     biophysical_features_target_protein['psites'].append(1 if index + 1 in phosphorylated else 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dda3fd2",
   "metadata": {},
   "source": [
    "### Get the dynamic properties in a pandas DataFrame object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "dfe85850",
   "metadata": {},
   "outputs": [],
   "source": [
    "dynamic_properties=pd.DataFrame(biophysical_features_target_protein)\n",
    "dynamic_properties['seqpos']=range(1,len(dynamic_properties)+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6df80d78",
   "metadata": {},
   "source": [
    "### Map onto AF models and visualize\n",
    "\n",
    "For visualizing the 3D structure, we'll use py3Dmol library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1e066d76",
   "metadata": {},
   "outputs": [],
   "source": [
    "import colorsys\n",
    "\n",
    "\n",
    "def pseudocolor(minval, maxval,val):\n",
    "    \"\"\" Convert predicted values min.....max in range Green...Yellow..RED \n",
    "        The colors correspond to Red and Green in the HSV colorspace\n",
    "    \"\"\"\n",
    "    minval,maxval=float(minval),float(maxval)\n",
    "    h = (float(maxval-val) / (maxval-minval)) * 120\n",
    "    r, g, b = colorsys.hsv_to_rgb(h/360, 1., 1.)\n",
    "    rgb=map(lambda x: int(255 * x), (r, g, b))\n",
    "    rgb=tuple(rgb)\n",
    "    rgb='0x%02x%02x%02x' % rgb\n",
    "    return rgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "53203ebf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def remap(df):\n",
    "    BDcolor,EFcolor,DOcolor={},{},{}\n",
    "    seqpos=0\n",
    "    min_BD,max_BD=min(df.backbone),max(df.backbone)\n",
    "    min_DO,max_DO=min(df.disoMine),max(df.disoMine)\n",
    "    min_EF,max_EF=min(df.earlyFolding),max(df.earlyFolding)\n",
    "    \n",
    "    for index, row in df.iterrows():\n",
    "        seqpos+=1\n",
    "        BDrescol=pseudocolor(min_BD,max_BD,float(row.backbone))\n",
    "        DOrescol=pseudocolor(min_EF,max_EF,float(row.disoMine))\n",
    "        EFrescol=pseudocolor(min_EF,max_EF,float(row.earlyFolding))\n",
    "        BDcolor[seqpos]=BDrescol\n",
    "        DOcolor[seqpos]=DOrescol\n",
    "        EFcolor[seqpos]=EFrescol\n",
    "        \n",
    "    return BDcolor,EFcolor,DOcolor\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "650fb2a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def display_3D(dynamic_properties):\n",
    "    BDcolor,EFcolor,DOcolor=remap(dynamic_properties)\n",
    "    \n",
    "    modpos=modification_table.position.tolist()\n",
    "    view = py3Dmol.view(viewergrid=(2,2))\n",
    "    view.addModel(open((accession+'.pdb'), 'r').read(),'pdb')\n",
    "   \n",
    "    \n",
    "    view.setStyle({'cartoon': {'colorscheme': {'prop':'b','gradient': 'rwb','min':0.0,'max':100.0}}},viewer=(0,0))\n",
    "    view.setStyle({'cartoon': {'colorscheme':{'prop':'resi','map':BDcolor}}}, viewer=(0,1))\n",
    "    view.setStyle({'cartoon': {'colorscheme':{'prop':'resi','map':DOcolor}}}, viewer=(1,0))\n",
    "    view.setStyle({'cartoon': {'colorscheme':{'prop':'resi','map':EFcolor}}}, viewer=(1,1))\n",
    "    \n",
    "    for mod in modpos:\n",
    "        view.addSurface(py3Dmol.VDW, {'opacity': 1.0},{'resi': [str(mod)]}, viewer=(0,0))\n",
    "        view.addSurface(py3Dmol.VDW, {'opacity': 1.0,'color':BDcolor[mod]}, {'resi': [str(mod)]}, viewer=(0,1))\n",
    "        view.addSurface(py3Dmol.VDW, {'opacity': 1.0,'color':DOcolor[mod]}, {'resi': [str(mod)]}, viewer=(1,0))\n",
    "        view.addSurface(py3Dmol.VDW, {'opacity': 1.0,'color':EFcolor[mod]}, {'resi': [str(mod)]}, viewer=(1,1))\n",
    "    \n",
    "    view.setBackgroundColor('#e6e6e6',viewer=(0,0))\n",
    "    view.setBackgroundColor('#e6e6e6',viewer=(0,1))        \n",
    "    view.setBackgroundColor('#e6e6e6',viewer=(1,0))\n",
    "    view.setBackgroundColor('#e6e6e6',viewer=(1,1))  \n",
    "\n",
    "    view.zoomTo()\n",
    "    view.render()\n",
    "    return view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "12d487e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "display_3D(dynamic_properties)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d90be79",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}