uniprot_domains.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "da117d0f",
   "metadata": {},
   "source": [
    "## Searching for Zinc Fingers, Coiled Coils, Transmembrane Regions, and Domains in UniProt Annotations\n",
    "\n",
    "This notebook reproduces Extended Data Fig. 1\n",
    "\n",
    "Author: Giulio Tesei\n",
    "\n",
    "Contact: giulio.tesei@bio.ku.dk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "f885d95a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import urllib.parse\n",
    "import urllib.request\n",
    "import json\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import time\n",
    "import matplotlib as mpl\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from ast import literal_eval\n",
    "from scipy.stats import binned_statistic, binned_statistic_2d\n",
    "plt.rcParams['font.family'] = 'sans-serif'\n",
    "plt.rcParams['font.sans-serif'] = ['Arial'] + plt.rcParams['font.sans-serif']\n",
    "mpl.rcParams['mathtext.fontset'] = 'custom'\n",
    "mpl.rcParams['mathtext.rm'] = 'Times New Roman'\n",
    "mpl.rcParams['mathtext.it'] = 'Times New Roman:italic'\n",
    "mpl.rc('pdf', fonttype=42)\n",
    "\n",
    "hexcolors = ['#EE7733', '#0077BB', '#33BBEE', '#EE3377', '#CC3311', '#009988', '#BBBBBB']\n",
    "colornames = ['orange','blue','cyan','magenta','red','teal','grey']\n",
    "pt_colors = dict(zip(colornames,hexcolors))\n",
    "\n",
    "def plot_bars_and_points(ax,df_idrome,df_spot,factor=1,prop='fdomain'):\n",
    "    # bin nu values\n",
    "    intervals = pd.cut(df_idrome['nu'], np.array([0, .45, .55, .9]))\n",
    "    df_1 = df_idrome[[prop]]*factor\n",
    "    df_1['nu_intervals'] = intervals\n",
    "    df_1['set'] = 'pLDDT'\n",
    "    intervals = pd.cut(df_spot['nu_svr'], np.array([0, .45, .55, .9]))\n",
    "    df_2 = df_spot[[prop]]*factor\n",
    "    df_2['nu_intervals'] = intervals\n",
    "    df_2['set'] = 'SPOT'\n",
    "    df = pd.concat([df_1,df_2]).reset_index().drop('seq_name',axis=1)\n",
    "    \n",
    "    n_pLDDT = df.query('set == \"pLDDT\"')['nu_intervals'].value_counts().sort_index().values\n",
    "    n_SPOT = df.query('set == \"SPOT\"')['nu_intervals'].value_counts().sort_index().values\n",
    "    \n",
    "    print(', '.join([str(x)+', '+str(y) for x,y in zip(n_pLDDT,n_SPOT)]))\n",
    "\n",
    "    sns.barplot(ax=ax,data=df,x='nu_intervals',y=prop,errorbar='se',hue='set',\n",
    "                      hue_order=['pLDDT', 'SPOT'],palette=['w','w'],capsize=.2,\n",
    "                      err_kws={'linewidth': .5},linewidth=1,gap=.2)\n",
    "\n",
    "    sns.stripplot(ax=ax,data=df,x='nu_intervals',y=prop,hue='set',hue_order=['pLDDT', 'SPOT'],\n",
    "                  palette=['w','w'],jitter=True,\n",
    "                  size=1.5,dodge=True,edgecolor='k',linewidth=.1,zorder=0,legend=False)\n",
    "\n",
    "    hatches = ['/////','']\n",
    "    for bars, hatch in zip(ax.containers, hatches):\n",
    "        for bar,color in zip(bars,[pt_colors['orange'],pt_colors['cyan'],pt_colors['teal']]):\n",
    "            bar.set_hatch(hatch)\n",
    "            bar.set_edgecolor(color)\n",
    "            bar.set_facecolor('None')\n",
    "\n",
    "    ax.legend([],[], frameon=False)\n",
    "\n",
    "    ax.set_xlim(-.5,2.5)\n",
    "    ax.set_xticks([-.5]+(np.arange(intervals.values.unique().sort_values().size)+.5).tolist())\n",
    "    ax.set_xticklabels([0]+[i.right for i in intervals.values.unique().sort_values()])\n",
    "\n",
    "    ax.set_xlabel('$\\\\nu$')\n",
    "    ax.set_ylabel(r'$f_{\\mathrm{domain}}$  %')\n",
    "    ax.set_yscale('symlog')\n",
    "    ax.set_yticks([0,1,10,100])\n",
    "    ax.set_yticklabels([0,1,10,100])\n",
    "\n",
    "def plot_halfviolin_and_points(ax,df_idrome,df_spot,prop='fdomain'):\n",
    "    # bin nu values\n",
    "    intervals = pd.cut(df_idrome['nu'], np.array([0, .45, .55, .9]))\n",
    "    df_1 = df_idrome[[prop]]*1\n",
    "    df_1['nu_intervals'] = intervals\n",
    "    df_1['set'] = 'pLDDT'\n",
    "    intervals = pd.cut(df_spot['nu_svr'], np.array([0, .45, .55, .9]))\n",
    "    df_2 = df_spot[[prop]]*1\n",
    "    df_2['nu_intervals'] = intervals\n",
    "    df_2['set'] = 'SPOT'\n",
    "    df = pd.concat([df_1,df_2]).reset_index().drop('seq_name',axis=1).explode(prop)\n",
    "    \n",
    "    n_pLDDT = df.query('set == \"pLDDT\"')['nu_intervals'].value_counts().sort_index().values\n",
    "    n_SPOT = df.query('set == \"SPOT\"')['nu_intervals'].value_counts().sort_index().values\n",
    "    \n",
    "    print(', '.join([str(x)+', '+str(y) for x,y in zip(n_pLDDT,n_SPOT)]))\n",
    "    \n",
    "    sns.violinplot(ax=ax,data=df,x='nu_intervals',y=prop,hue='set',\n",
    "                      hue_order=['pLDDT', 'SPOT'],palette=['w','w'],linestyle='-',\n",
    "                      linewidth=.8,split=True,inner='quart',linecolor='k',gap=.1)\n",
    "\n",
    "    hatches = ['/////','']\n",
    "    for violin, hatch, color in zip(ax.collections, ['/////','']*3,\n",
    "                           np.repeat([pt_colors['orange'],pt_colors['cyan'],pt_colors['teal']],2)):\n",
    "        violin.set_edgecolor(color)\n",
    "        violin.set_edgecolor(color)\n",
    "        violin.set_hatch(hatch)\n",
    "        violin.set_facecolor('None')\n",
    "        \n",
    "    for l in ax.lines:\n",
    "        l.set_linestyle('-')\n",
    "        l.set_linewidth(.5)\n",
    "        l.set_color('k')\n",
    "        l.set_alpha(1)\n",
    "    for l in ax.lines[1::3]:\n",
    "        l.set_linestyle('-')\n",
    "        l.set_linewidth(1)\n",
    "        l.set_color('k')\n",
    "        l.set_alpha(1)\n",
    "\n",
    "    ax.legend([],[], frameon=False)\n",
    "\n",
    "    ax.set_xlim(-.5,2.5)\n",
    "    ax.set_xticks([-.5]+(np.arange(intervals.values.unique().sort_values().size)+.5).tolist())\n",
    "    ax.set_xticklabels([0]+[i.right for i in intervals.values.unique().sort_values()])\n",
    "\n",
    "    ax.set_xlabel('$\\\\nu$')\n",
    "    ax.set_ylabel(r'$f_{\\mathrm{domain}}$  %')\n",
    "    ax.set_yscale('symlog')\n",
    "\n",
    "# function to calculate standard error of the mean\n",
    "se = lambda x : np.std(x)/np.sqrt(x.size)\n",
    "se.__name__ = 'SE'\n",
    "\n",
    "partial_match = ['KRAB','Protein kinase','Collagen-like','Zinc finger','Rab-GAP TBC','BTB','FERM','ZP',\n",
    "'B30.2/SPRY','SET','PID','Cadherin','Fibronectin type-III','IQ','TSP type-1','Ig-like','ABC transporter',\n",
    "'EGF-like','CARD','PDZ','SH3','SAM','uDENN','Peptidase S1','Ras-GEF','Ras-associating','Olduvai','EF-hand']\n",
    "\n",
    "exact_match = ['Transmembrane','Coiled coil','USP','PH','Myosin motor',\n",
    "'Teneurin N-terminal','Helicase ATP-binding','REJ','cDENN FNIP1/2-type','FH2','C2',\n",
    "'NR LBD','AGC-kinase C-terminal', 'Myotubularin phosphatase',\n",
    "'Helicase C-terminal','PCI', 'DDHD',\n",
    "'G-patch','STAS','Kinesin motor','uDENN FNIP1/2-type', 'PLAC','RID','SCAN box',\n",
    "'PPM-type phosphatase', 'MDFI','I/LWEQ', 'MARVEL',\n",
    "'HIG1', 'KAP NTPase', 'CNH','PLA2c',\n",
    "'MACPF', 'DMAP1-binding', 'Sema','ASD2', 'NACHT', \n",
    "'IBB', 'GBD/FH3', 'IF rod', 'PARP catalytic','Sox C-terminal', 'Rho-GAP',\n",
    "'Pyrin','cDENN FLCN/SMCR8-type','Reticulon','WW']\n",
    "\n",
    "frequent_domains = partial_match + exact_match\n",
    "\n",
    "def idr_uniprot_features(df,name,annotation,start_feature,end_feature,exact_match,partial_match):\n",
    "    features = []\n",
    "    descriptions = []\n",
    "    start_index = df.loc[name,'first']\n",
    "    end_index = df.loc[name,'last']\n",
    "    folded_counter = np.zeros(end_index-start_index+1)\n",
    "    if (start_feature < start_index):\n",
    "        start_feature = start_index\n",
    "    if (end_feature > end_index):\n",
    "        end_feature = end_index\n",
    "    length = end_feature-start_feature\n",
    "    if length >= 10:\n",
    "        folded_counter[start_feature-start_index:end_feature-start_index] += 1\n",
    "        features.append(annotation['type'])\n",
    "        if annotation['type'] == 'Zinc finger':\n",
    "            descriptions.append('Zinc finger')\n",
    "        elif annotation['type'] == 'Coiled coil':\n",
    "            descriptions.append('Coiled coil')\n",
    "        elif annotation['type'] == 'Transmembrane':\n",
    "            descriptions.append('Transmembrane')\n",
    "        else:\n",
    "            descriptions.append(annotation['description'])\n",
    "        for domain in exact_match:\n",
    "            if domain == descriptions[-1]:\n",
    "                df.loc[name,domain] += length\n",
    "        for domain in partial_match:\n",
    "            if domain in descriptions[-1]:\n",
    "                df.loc[name,domain] += length\n",
    "        if descriptions[-1] in ['PH 1','PH 2','PH 3','PH 4']:\n",
    "            df.loc[name,'PH'] += length\n",
    "        elif descriptions[-1] in ['C2 1','C2 2','C2 3','C2 4','C2 5','C2 6']:\n",
    "            df.loc[name,'C2'] += length\n",
    "        elif descriptions[-1] in ['WW 1','WW 2','WW 3','WW 4']:\n",
    "            df.loc[name,'WW'] += length\n",
    "        df.loc[name,'N_Domain'] = np.sum(folded_counter!=0)\n",
    "        df.loc[name,'Features'] = ', '.join(np.unique(features))\n",
    "        df.loc[name,'Descriptions'] = ', '.join(np.unique(descriptions))\n",
    "        \n",
    "def uniprot_api_features(UniProt_ID,df_FL,df_idrome,df_spot,exact_match,partial_match):\n",
    "    # Use the uniprot as input to fetch the protein name\n",
    "    idrome_names = df_idrome.query(f'UniProt_ID == \"{UniProt_ID:s}\"').index\n",
    "    spot_names = df_spot.query(f'UniProt_ID == \"{UniProt_ID:s}\"').index\n",
    "    url_template_uniprot = \"https://rest.uniprot.org/uniprotkb/{}.json\"\n",
    "    url_uniprot = url_template_uniprot.format(UniProt_ID)\n",
    "    \n",
    "    with urllib.request.urlopen(url_uniprot) as link:\n",
    "        data_uniprot = json.loads(link.read().decode())\n",
    "        try:\n",
    "            annotations = data_uniprot['features']\n",
    "        except:\n",
    "            return 'No features'\n",
    "        N_FL_UP = data_uniprot['sequence']['length']\n",
    "        df_FL.loc[UniProt_ID,'N_FL_UP'] = N_FL_UP\n",
    "        if len(idrome_names) > 0:\n",
    "            N_FL_IDRome = df_idrome.query(f'UniProt_ID == \"{UniProt_ID:s}\"').N_FL[0]\n",
    "            if N_FL_IDRome != N_FL_UP:\n",
    "                print('length mismatch',N_FL_UP,N_FL_IDRome)\n",
    "                df_FL.loc[UniProt_ID,'N_FL_IDRome'] = N_FL_IDRome\n",
    "        if len(spot_names) > 0:\n",
    "            N_FL_SPOT = df_spot.query(f'UniProt_ID == \"{UniProt_ID:s}\"').N_FL[0]\n",
    "            if N_FL_SPOT != N_FL_UP:\n",
    "                print('length mismatch',N_FL_UP,N_FL_SPOT)\n",
    "                df_FL.loc[UniProt_ID,'N_FL_SPOT'] = N_FL_SPOT\n",
    "        if len(annotations) > 0:\n",
    "            folded_counter_FL = np.zeros(N_FL_UP)\n",
    "            features = []\n",
    "            descriptions = []\n",
    "            for annotation in annotations:\n",
    "                if annotation['type'] in ['Domain','Zinc finger','Coiled coil','Transmembrane']:\n",
    "                    start_feature = annotation['location']['start']['value']\n",
    "                    end_feature = annotation['location']['end']['value']\n",
    "                    if start_feature == None:\n",
    "                        length = 0\n",
    "                    elif end_feature == None:\n",
    "                        length = 0\n",
    "                    else:\n",
    "                        length = end_feature-start_feature\n",
    "                    if length >= 10:\n",
    "                        folded_counter_FL[start_feature:end_feature] += 1\n",
    "                        features.append(annotation['type'])\n",
    "                        if annotation['type'] == 'Zinc finger':\n",
    "                            descriptions.append('Zinc finger')\n",
    "                        elif annotation['type'] == 'Coiled coil':\n",
    "                            descriptions.append('Coiled coil')\n",
    "                        elif annotation['type'] == 'Transmembrane':\n",
    "                            descriptions.append('Transmembrane')\n",
    "                        else:\n",
    "                            descriptions.append(annotation['description'])\n",
    "                        for domain in exact_match:\n",
    "                            if domain == descriptions[-1]:\n",
    "                                df_FL.loc[UniProt_ID,domain] += length\n",
    "                        for domain in partial_match:\n",
    "                            if domain in descriptions[-1]:\n",
    "                                df_FL.loc[UniProt_ID,domain] += length\n",
    "                        if descriptions[-1] in ['PH 1','PH 2','PH 3','PH 4']:\n",
    "                            df_FL.loc[UniProt_ID,'PH'] += length\n",
    "                        elif descriptions[-1] in ['C2 1','C2 2','C2 3','C2 4','C2 5','C2 6']:\n",
    "                            df_FL.loc[UniProt_ID,'C2'] += length\n",
    "                        elif descriptions[-1] in ['WW 1','WW 2','WW 3','WW 4']:\n",
    "                            df_FL.loc[UniProt_ID,'WW'] += length\n",
    "                        df_FL.loc[UniProt_ID,'N_Domain'] = np.sum(folded_counter_FL!=0)\n",
    "                        df_FL.loc[UniProt_ID,'Features'] = ', '.join(np.unique(features))\n",
    "                        df_FL.loc[UniProt_ID,'Descriptions'] = ', '.join(np.unique(descriptions))\n",
    "                        for idrome_name in idrome_names:\n",
    "                            idr_uniprot_features(df_idrome,idrome_name,annotation,\n",
    "                                                 start_feature,end_feature,exact_match,partial_match)\n",
    "                        for spot_name in spot_names:\n",
    "                            idr_uniprot_features(df_spot,spot_name,annotation,\n",
    "                                                 start_feature,end_feature,exact_match,partial_match)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a7258f9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15955"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load IDRome database\n",
    "df_idrome = pd.read_csv('IDRome_DB.csv',index_col=0)[['nu','SPR','UniProt_ID','N',\n",
    "                                                      'first','last','N_FL','is_btw_folded','is_nterm',\n",
    "                                                      'is_cterm','is_idp']]\n",
    "df_idrome[frequent_domains] = 0\n",
    "# Load SPOT database\n",
    "df_spot = pd.read_csv('IDRome_DB_SPOT.csv',index_col=0)[['nu_svr','SPR_svr','UniProt_ID','N',\n",
    "                                                         'first','last','N_FL','is_btw_folded','is_nterm',\n",
    "                                                      'is_cterm','is_idp']]\n",
    "df_spot[frequent_domains] = 0\n",
    "\n",
    "UniProt_IDs = np.unique(np.append(df_idrome.UniProt_ID,df_spot.UniProt_ID))\n",
    "\n",
    "# Create FL database\n",
    "df_FL = pd.DataFrame(index=UniProt_IDs,columns=['N_Domain','Features','Descriptions',\n",
    "                                               'N_FL_UP','N_FL_IDRome','N_FL_SPOT'])\n",
    "df_FL[frequent_domains] = 0\n",
    "\n",
    "len(UniProt_IDs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a34d0fd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i,UniProt_ID in enumerate(UniProt_IDs[:]):\n",
    "    uniprot_api_features(UniProt_ID,df_FL,df_idrome,df_spot,exact_match,partial_match)\n",
    "    print(i,end='-')\n",
    "    time.sleep(.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5d223a4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_idrome['N_Domain'] = df_idrome['N_Domain'].fillna(0) \n",
    "df_idrome['fdomain'] = df_idrome['N_Domain'] / df_idrome['N']\n",
    "df_idrome.to_csv('IDRome_DB_Domains.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9130613c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_spot['N_Domain'] = df_spot['N_Domain'].fillna(0) \n",
    "df_spot['fdomain'] = df_spot['N_Domain'] / df_spot['N']\n",
    "df_spot.to_csv('IDRome_DB_SPOT_Domains.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "dffa90f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_FL['N_Domain'] = df_FL['N_Domain'].fillna(0) \n",
    "df_FL['fdomain'] = df_FL['N_Domain'] / df_FL['N_FL_UP']\n",
    "df_FL.to_csv('FL_Domains.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "42bd858b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load domain annotations\n",
    "df_idrome = pd.read_csv('IDRome_DB_Domains.csv',index_col=0)\n",
    "df_spot = pd.read_csv('IDRome_DB_SPOT_Domains.csv',index_col=0)\n",
    "df_FL = pd.read_csv('FL_Domains.csv',index_col=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9e2076f",
   "metadata": {},
   "source": [
    "#### Calculate the overlap between pLDDT-based and SPOT-based sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "0157d7b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(63.79834447925923, 19.342468315951926, 83.14081279521115)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cnt_spot = 0\n",
    "cnt_idrome = 0\n",
    "for up_id in df_spot.UniProt_ID.unique():\n",
    "    idrs_idrome = df_idrome.query(f'UniProt_ID == \"{up_id:s}\"')\n",
    "    idrs_spot = df_spot.query(f'UniProt_ID == \"{up_id:s}\"')\n",
    "    for ndx_spot in idrs_spot.index:\n",
    "        first_spot = idrs_spot.loc[ndx_spot,'first']\n",
    "        last_spot = idrs_spot.loc[ndx_spot,'last']\n",
    "        for ndx_idrome in idrs_idrome.index:\n",
    "            first = idrs_idrome.loc[ndx_idrome,'first']\n",
    "            last = idrs_idrome.loc[ndx_idrome,'last']\n",
    "            if (first_spot >= first) and (last_spot <= last):\n",
    "                cnt_spot += 1\n",
    "            elif (first >= first_spot) and (last <= last_spot):\n",
    "                cnt_idrome += 1\n",
    "\n",
    "cnt_spot/df_spot.shape[0]*100,cnt_idrome/df_spot.shape[0]*100,(cnt_spot+cnt_idrome)/df_spot.shape[0]*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "79e50eeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_idrome.Descriptions = df_idrome.Descriptions.apply(lambda x : x.split(',') if type(x)!=float else x)\n",
    "df_spot.Descriptions = df_spot.Descriptions.apply(lambda x : x.split(',') if type(x)!=float else x)\n",
    "df_FL.Descriptions = df_FL.Descriptions.apply(lambda x : x.split(',') if type(x)!=float else x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e608094",
   "metadata": {},
   "source": [
    "#### Rename Domains with Shorthand Descriptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2f368bfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_w_substring(strings,shorthand_description):\n",
    "    for i,string in enumerate(strings):\n",
    "        for substring in shorthand_description:\n",
    "            if substring in string:\n",
    "                strings[i] = substring\n",
    "        if string in ['PH 1','PH 2','PH 3','PH 4']:\n",
    "            strings[i] = 'PH'\n",
    "        if string in ['C2 1','C2 2','C2 3','C2 4','C2 5','C2 6']:\n",
    "            strings[i] = 'C2'\n",
    "        if string in ['WW 1','WW 2','WW 3','WW 4']:\n",
    "            strings[i] = 'WW'\n",
    "    if 'Zinc finger' in strings:\n",
    "        strings = ['Zinc finger']\n",
    "    if '' in strings:\n",
    "        strings.remove('')\n",
    "    return np.unique(strings)\n",
    "\n",
    "df_idrome['Short_Descriptions'] = df_idrome[~pd.isnull(df_idrome.Descriptions)].Descriptions.apply(\n",
    "    lambda x : replace_w_substring(x,partial_match))\n",
    "\n",
    "df_spot['Short_Descriptions'] = df_spot[~pd.isnull(df_spot.Descriptions)].Descriptions.apply(\n",
    "    lambda x : replace_w_substring(x,partial_match))\n",
    "\n",
    "df_FL['Short_Descriptions'] = df_FL[~pd.isnull(df_FL.Descriptions)].Descriptions.apply(\n",
    "    lambda x : replace_w_substring(x,partial_match))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21ce8e16",
   "metadata": {},
   "source": [
    "#### Descriptions for IDRs with Multiple Domains of Different Type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "158b9005",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_idrome['Short_Descriptions'] = df_idrome[~pd.isnull(df_idrome.Descriptions)].Short_Descriptions.apply(\n",
    "    lambda x : ' & '.join([str(s) for s in x]))\n",
    "df_spot['Short_Descriptions'] = df_spot[~pd.isnull(df_spot.Descriptions)].Short_Descriptions.apply(\n",
    "    lambda x : ' & '.join([str(s) for s in x]))\n",
    "df_FL['Short_Descriptions'] = df_FL[~pd.isnull(df_FL.Descriptions)].Short_Descriptions.apply(\n",
    "    lambda x : ' & '.join([str(s) for s in x]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "2b791880",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.432176206429539, 6204)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_idrome.query('fdomain > 0.9').shape[0]/df_idrome.shape[0]*100,df_idrome.query('fdomain > 0').shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "973550d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(19.150727213206753, 4095)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_spot.query('fdomain > 0').shape[0]/df_spot.shape[0]*100,df_spot.query('fdomain > 0').shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "2bb51a1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.07642403014455885, 0.06747993214094654)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_idrome.fdomain.mean(),df_spot.fdomain.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "eb6ba52e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.821735230526131 5.554876270915435\n"
     ]
    }
   ],
   "source": [
    "print((df_idrome.fdomain*df_idrome.N).sum()/df_idrome.N.sum()*100,\n",
    "(df_spot.fdomain*df_spot.N).sum()/df_spot.N.sum()*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a89b41a",
   "metadata": {},
   "source": [
    "#### Calculate Average pLDDT Scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "9b57c45a",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_pLDDT = pd.read_csv('idr_selection/idr.csv.gz',header=0,sep=';')\n",
    "df_pLDDT['seq_name'] = df_pLDDT.uniprot+'_'+df_pLDDT['first'].apply(\n",
    "    lambda x : '{:g}'.format(x))+'_'+df_pLDDT['last'].apply(lambda x : '{:g}'.format(x))\n",
    "df_pLDDT.set_index('seq_name',inplace=True)\n",
    "df_pLDDT['is_btw_folded'] = df_idrome.loc[df_pLDDT.index,'is_btw_folded']\n",
    "df_pLDDT['is_idp'] = df_idrome.loc[df_pLDDT.index,'is_idp']\n",
    "df_pLDDT['fdomain'] = df_idrome.loc[df_pLDDT.index,'fdomain']\n",
    "df_pLDDT['nu'] = df_idrome.loc[df_pLDDT.index,'nu']\n",
    "\n",
    "df_pLDDT['pLDDT_w20'] = df_pLDDT['pLDDT_w20'].apply(lambda x : 100*np.array(eval(x.replace(':',','))))\n",
    "pLDDT_w20_idrome = np.array([y for x in df_pLDDT['pLDDT_w20'].values for y in x])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "39cce508",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(21383, 11)\n",
      "(21277, 11)\n"
     ]
    }
   ],
   "source": [
    "df_pLDDT_spot = pd.read_csv('idr_selection/idr_spot.csv.gz',header=0,sep=';')\n",
    "df_pLDDT_spot['seq_name'] = df_pLDDT_spot.uniprot+'_'+df_pLDDT_spot['first'].apply(\n",
    "    lambda x : '{:g}'.format(x))+'_'+df_pLDDT_spot['last'].apply(lambda x : '{:g}'.format(x))\n",
    "df_pLDDT_spot.set_index('seq_name',inplace=True)\n",
    "df_pLDDT_spot['is_btw_folded'] = df_spot.loc[df_pLDDT_spot.index,'is_btw_folded']\n",
    "df_pLDDT_spot['nu_svr'] = df_spot.loc[df_pLDDT_spot.index,'nu_svr']\n",
    "\n",
    "IDR_no_pLDDT = []\n",
    "for seq_name in df_pLDDT_spot.index:\n",
    "    try:\n",
    "        100*eval(df_pLDDT_spot.loc[seq_name].pLDDT_w20.replace(':',','))\n",
    "    except NameError:\n",
    "        IDR_no_pLDDT.append(seq_name)\n",
    "        \n",
    "print(df_pLDDT_spot.shape)\n",
    "df_pLDDT_spot.drop(IDR_no_pLDDT,inplace=True)\n",
    "print(df_pLDDT_spot.shape)\n",
    "df_pLDDT_spot['pLDDT_w20'] = df_pLDDT_spot['pLDDT_w20'].apply(lambda x : 100*np.array(eval(x.replace(':',','))))\n",
    "UniProt_ID_diff = np.unique(np.setxor1d(df_pLDDT_spot.uniprot,df_pLDDT.uniprot))\n",
    "pLDDT_w20_idrome_spot = np.array([y for x in df_pLDDT_spot['pLDDT_w20'].values for y in x])\n",
    "pLDDT_w20_unique_spot = np.array([y for x in df_pLDDT_spot[df_pLDDT_spot.uniprot.isin(\n",
    "    UniProt_ID_diff)]['pLDDT_w20'].values for y in x])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cc47df9",
   "metadata": {},
   "source": [
    "#### Extended Data Fig. 1a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "2735ece8",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "161748, 88325, 3278851, 2442776, 511556, 429591\n",
      "13988, 8534, 374190, 275164, 92770, 66276\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 660x200 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax1,ax2,ax3) = plt.subplots(1, 3, sharex=False, sharey=False, figsize=(6.6,2))\n",
    "plt.rc('font', **{'family':'sans-serif','sans-serif':['Arial'], 'size': 6})\n",
    "mpl.rcParams['pdf.fonttype'] = 42\n",
    "\n",
    "bin_width = 2\n",
    "bins = np.arange(19.5, 100+bin_width, bin_width)\n",
    "x = bins[:-1]+bin_width/2\n",
    "\n",
    "ax1.hist(pLDDT_w20_idrome,\n",
    "         bins,density=True,histtype='step',\n",
    "         color=pt_colors['grey'],zorder=1,label='pLDDT-based')\n",
    "\n",
    "ax1.hist(pLDDT_w20_idrome_spot,\n",
    "         bins,density=True,histtype='step',\n",
    "         color=pt_colors['red'],zorder=1,label='SPOT-based')\n",
    "\n",
    "ax1.hist(pLDDT_w20_unique_spot,\n",
    "         bins,density=True,histtype='step',\n",
    "         color=pt_colors['magenta'],zorder=1,label='SPOT-based Unique')\n",
    "\n",
    "ax1.set_ylabel('Normalized Distribution')\n",
    "ax1.set_xlabel(r'pLDDT Score')\n",
    "\n",
    "ax1.legend(frameon=False,loc='upper right',handlelength=1)\n",
    "ax1.set_xlim(20,100)\n",
    "\n",
    "######\n",
    "\n",
    "plot_halfviolin_and_points(ax2,df_pLDDT,df_pLDDT_spot,prop='pLDDT_w20')\n",
    "\n",
    "plot_halfviolin_and_points(ax3,df_pLDDT.query('is_btw_folded'),\n",
    "                     df_pLDDT_spot.query('is_btw_folded'),prop='pLDDT_w20')\n",
    "\n",
    "#f_mean_pLDDT = lambda values : np.quantile(np.array([y for x in values for y in x]),q=.75)\n",
    "#f_mean_pLDDT.__name__ = 'mean_pLDDT'\n",
    "#intervals = pd.cut(df_idrome['nu'], np.array([0, .45, .55, .9]))\n",
    "#for m in df_pLDDT.groupby(intervals)['pLDDT_w20'].agg(f_mean_pLDDT).values:\n",
    "#    ax2.axhline(m,lw=.5)\n",
    "    \n",
    "#intervals = pd.cut(df_pLDDT_spot['nu_svr'], np.array([0, .45, .55, .9]))\n",
    "#for m in df_pLDDT_spot.groupby(intervals)['pLDDT_w20'].agg(f_mean_pLDDT).values:\n",
    "#    ax2.axhline(m,color='r',lw=.5)\n",
    "\n",
    "ax2.set_xlabel('$\\\\nu$')\n",
    "ax2.set_ylabel(r'pLDDT Score')\n",
    "ax2.set_ylim(20,100)\n",
    "ax2.set_yticks([20,40,60,80,100])\n",
    "ax2.set_yticklabels([20,40,60,80,100])\n",
    "\n",
    "ax3.set_xlabel('$\\\\nu$')\n",
    "ax3.set_ylabel(r'pLDDT Score')\n",
    "ax3.set_ylim(20,100)\n",
    "ax3.set_yticks([20,40,60,80,100])\n",
    "ax3.set_yticklabels([20,40,60,80,100])\n",
    "######\n",
    "\n",
    "ax2.set_title('All IDRs')\n",
    "ax3.set_title('IDRs Between Folded Domains')\n",
    "\n",
    "fig.text(0.01, .92, 'a', fontsize=10)\n",
    "fig.text(0.34, .92, 'b', fontsize=10)\n",
    "fig.text(0.67, .92, 'c', fontsize=10)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('figs/ED_fig1a.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88886929",
   "metadata": {},
   "source": [
    "#### Extended Data Fig. 1b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "13ce214c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    6204\n",
      "dtype: int64\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 660x150 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax1,ax2) = plt.subplots(1, 2, sharex=False, sharey=False, figsize=(6.6,1.5))\n",
    "plt.rc('font', **{'family':'sans-serif','sans-serif':['Arial'], 'size': 6})\n",
    "\n",
    "intervals = pd.cut(df_idrome['fdomain'], np.arange(0, 1.05, .1))\n",
    "fdomain_counts = df_idrome['fdomain'].groupby(intervals).agg(['count'])#/df_idrome['fdomain'].size*100\n",
    "fdomain_counts.plot(rot=0, ax=ax1, kind='bar',hatch='/////',color='w', \n",
    "                      edgecolor=pt_colors['grey'],width=1,legend=False)\n",
    "\n",
    "print(fdomain_counts.sum())\n",
    "\n",
    "intervals = pd.cut(df_spot['fdomain'], np.arange(0, 1.05, .1))\n",
    "fdomain_counts = df_spot['fdomain'].groupby(intervals).agg(['count'])#/df_spot['fdomain'].size*100\n",
    "fdomain_counts.plot(rot=0, ax=ax1, kind='bar',hatch='/////',color='None', \n",
    "                      edgecolor=pt_colors['red'],width=.5,legend=False)\n",
    "\n",
    "ax1.set_ylabel('Number of IDRs')\n",
    "\n",
    "ax1.set_xticks([-.5]+(np.arange(fdomain_counts.index.size)+.5).tolist())\n",
    "ax1.set_xticklabels([0]+[i.right for i in fdomain_counts.index])\n",
    "\n",
    "intervals = pd.cut(df_idrome['fdomain'], np.arange(0, 1.05, .1))\n",
    "mean_se = df_idrome['N'].groupby(intervals).agg(['mean',se])\n",
    "mean_se['mean'].plot(rot=0, ax=ax2, kind='bar', yerr=mean_se['SE'],hatch='/////',color='w',\n",
    "                      edgecolor=pt_colors['grey'],\n",
    "                      error_kw=dict(ecolor=pt_colors['grey'],elinewidth=0.5,capsize=2),width=1)\n",
    "\n",
    "intervals = pd.cut(df_spot['fdomain'], np.arange(0, 1.05, .1))\n",
    "mean_se = df_spot['N'].groupby(intervals).agg(['mean',se])\n",
    "mean_se['mean'].plot(rot=0, ax=ax2, kind='bar', yerr=mean_se['SE'],hatch='/////',color='None',\n",
    "                      edgecolor=pt_colors['red'],\n",
    "                      error_kw=dict(ecolor=pt_colors['red'],elinewidth=0.5,capsize=2),width=.5)\n",
    "\n",
    "ax2.set_ylabel('Sequence Length')\n",
    "ax1.set_xlabel(r'$f_{\\mathrm{domain}}$')\n",
    "ax2.set_xlabel(r'$f_{\\mathrm{domain}}$')\n",
    "\n",
    "ax2.set_xticks([-.5]+(np.arange(mean_se.index.size)+.5).tolist())\n",
    "ax2.set_xticklabels([0]+[i.right for i in mean_se.index])\n",
    "\n",
    "fig.text(0.01, .9, 'd', fontsize=10)\n",
    "fig.text(0.506, .9, 'e', fontsize=10)\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "fig.savefig('figs/ED_fig1b.pdf',dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce8aa1ad",
   "metadata": {},
   "source": [
    "#### Extended Data Fig. 1c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "6829a56b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "616, 361, 18546, 13292, 8896, 7730\n",
      "91, 56, 2470, 1613, 1777, 1214\n",
      "415, 203, 12144, 6531, 4776, 3601\n",
      "43, 12, 1346, 517, 74, 50\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 660x400 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(6.6,4))\n",
    "ax1 = plt.subplot2grid( (2,4), (0,0), rowspan=1, colspan=1 )\n",
    "ax2 = plt.subplot2grid( (2,4), (0,1), rowspan=1, colspan=1 )\n",
    "ax3 = plt.subplot2grid( (2,4), (0,2), rowspan=1, colspan=1 )\n",
    "ax4 = plt.subplot2grid( (2,4), (0,3), rowspan=1, colspan=1 )\n",
    "ax5 = plt.subplot2grid( (2,4), (1,0), rowspan=1, colspan=4 )\n",
    "plt.rc('font', **{'family':'sans-serif','sans-serif':['Arial'], 'size': 6})\n",
    "\n",
    "plot_bars_and_points(ax1,df_idrome,df_spot,100)\n",
    "\n",
    "for ax,group in zip([ax2,ax3,ax4],['is_btw_folded','is_nterm or is_cterm','is_idp']):\n",
    "    \n",
    "    plot_bars_and_points(ax,df_idrome.query(group),df_spot.query(group),100)\n",
    "    \n",
    "ax1.set_title('All IDRs')\n",
    "ax2.set_title('IDRs Between Folded Domains')\n",
    "ax3.set_title('N- and C-terminal IDRs')\n",
    "ax4.set_title('IDPs')\n",
    "\n",
    "counts = pd.DataFrame(columns=['IDRome','SPOT','Full-Length'])\n",
    "counts['IDRome'] = df_idrome[frequent_domains].sum().sort_values(ascending=False) \n",
    "counts['SPOT'] = df_spot[frequent_domains].sum()\n",
    "counts['Full-Length'] = df_FL[frequent_domains].sum()\n",
    "#counts = counts[counts>=20]\n",
    "counts.index\n",
    "counts.plot.bar(ax=ax5,color=[pt_colors['grey'],pt_colors['red'],pt_colors['blue']])\n",
    "\n",
    "ax5.set_ylabel('Number of Residues')\n",
    "ax5.set_yscale('symlog')\n",
    "ax5.set_ylim(0,1e6)\n",
    "ax5.set_xlim(-.5,62.5)\n",
    "\n",
    "ax5.legend(frameon=False,ncol=3)\n",
    "\n",
    "fig.text(0.01, .955, 'f', fontsize=10)\n",
    "fig.text(0.27, .955, 'g', fontsize=10)\n",
    "fig.text(0.53, .955, 'h', fontsize=10)\n",
    "fig.text(0.77, .955, 'i', fontsize=10)\n",
    "fig.text(0.01, .56, 'j', fontsize=10)\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "fig.savefig('figs/ED_fig1c.pdf',dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1989c68f",
   "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.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}