clinvar_fmug.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0ff02100",
   "metadata": {},
   "source": [
    "## Analyses of clinical data, conformational buffering, and number of publications obtained from the [FMUG tool](https://fmug.amaral.northwestern.edu/)\n",
    "\n",
    "This notebook reproduces Fig. 5 and Extended Data Fig. 9\n",
    "\n",
    "Authors: Giulio Tesei\n",
    "\n",
    "Contact: giulio.tesei@bio.ku.dk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "f36e5140",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import glob \n",
    "import time\n",
    "import os\n",
    "import random\n",
    "from scipy import stats\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "from matplotlib.colors import LogNorm\n",
    "from scipy.optimize import curve_fit\n",
    "import itertools\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import pearsonr, spearmanr, gaussian_kde, ttest_ind\n",
    "from scipy.stats import binned_statistic, binned_statistic_2d\n",
    "from ast import literal_eval\n",
    "import seaborn as sns\n",
    "from joblib import dump, load\n",
    "from localcider.sequenceParameters import SequenceParameters\n",
    "from statsmodels.stats.nonparametric import rank_compare_2indep\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",
    "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",
    "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",
    "def bootstrapped_cohens_d(a,b,n_bootstrap):\n",
    "    cohens_d = (a.mean()-b.mean()) / np.sqrt(0.5*(a.std()**2+b.std()**2))\n",
    "    cohens_d_bootstrap = np.empty(0)\n",
    "    for _ in range(n_bootstrap):\n",
    "        a_p = np.random.choice(a,size=a.size)\n",
    "        b_p = np.random.choice(b,size=b.size)\n",
    "        cohens_d_b = (a_p.mean()-b_p.mean()) / np.sqrt(0.5*(a_p.std()**2+b_p.std()**2))\n",
    "        cohens_d_bootstrap = np.append(cohens_d_bootstrap,cohens_d_b)\n",
    "    return cohens_d, np.std(cohens_d_bootstrap)\n",
    "\n",
    "def calc_dof(x,y):\n",
    "    nx = x.size\n",
    "    ny = y.size\n",
    "    rankc = stats.rankdata(np.concatenate((x,y)))\n",
    "    rankcx = rankc[0:nx]\n",
    "    rankcy = rankc[nx:nx+ny]\n",
    "    rankcx_mean = np.mean(rankcx)\n",
    "    rankcy_mean = np.mean(rankcy)\n",
    "    rankx = stats.rankdata(x)\n",
    "    ranky = stats.rankdata(y)\n",
    "    rankx_mean = np.mean(rankx)\n",
    "    ranky_mean = np.mean(ranky)\n",
    "\n",
    "    Sx = np.sum(np.power(rankcx - rankx - rankcx_mean + rankx_mean, 2.0))\n",
    "    Sx /= nx - 1\n",
    "    Sy = np.sum(np.power(rankcy - ranky - rankcy_mean + ranky_mean, 2.0))\n",
    "    Sy /= ny - 1\n",
    "\n",
    "    df_numer = np.power(nx * Sx + ny * Sy, 2.0)\n",
    "    df_denom = np.power(nx * Sx, 2.0) / (nx - 1)\n",
    "    df_denom += np.power(ny * Sy, 2.0) / (ny - 1)\n",
    "    return df_numer / df_denom\n",
    "\n",
    "def plot_hist_variants(ax,df_idrome,intervals,xlabel,w=.6,\n",
    "                      hatch='////',color=['tab:orange']*8+['tab:blue']*2+['tab:green']*4):\n",
    "    \n",
    "    mean_se = df_idrome.groupby(intervals).agg(['mean',se])\n",
    "    mean_se.rename(columns={'n_benign': 'Benign', 'n_pathogenic':'Pathogenic'},\n",
    "                   inplace=True)\n",
    "    \n",
    "    mean_se.xs('mean',axis=1,level=1).plot(rot=90, ax=ax, kind='bar', \n",
    "                    yerr=mean_se.xs('SE',axis=1,level=1),\n",
    "                    width=w,zorder=1,\n",
    "                    error_kw=dict(ecolor='black',elinewidth=0.5,capsize=1.5),\n",
    "                    label='w/o del',hatch=hatch,color='w',\n",
    "                    edgecolor=['tab:orange']*8+['tab:blue']*2+['tab:green']*4,legend=False)\n",
    "    \n",
    "    subset = mean_se.copy()\n",
    "    subset.iloc[8:] = np.nan\n",
    "    \n",
    "    subset.xs('mean',axis=1,level=1).plot(rot=90, ax=ax, kind='bar', \n",
    "                    width=w,zorder=1,hatch=hatch,color=['tab:orange','w'],\n",
    "                    edgecolor=['tab:orange']*8+['w']*5,legend=False)\n",
    "    \n",
    "    subset = mean_se.copy()\n",
    "    subset.iloc[:8] = np.nan\n",
    "    subset.iloc[10:] = np.nan\n",
    "    \n",
    "    subset.xs('mean',axis=1,level=1).plot(rot=90, ax=ax, kind='bar', \n",
    "                    width=w,zorder=1,hatch=hatch,color=['tab:blue','w'],\n",
    "                    edgecolor=['w']*8+['tab:blue']*2+['w']*4,legend=False)\n",
    "    \n",
    "    subset = mean_se.copy()\n",
    "    subset.iloc[:10] = np.nan\n",
    "    \n",
    "    subset.xs('mean',axis=1,level=1).plot(rot=90, ax=ax, kind='bar', \n",
    "                    width=w,zorder=1,hatch=hatch,color=['tab:green','w'],\n",
    "                    edgecolor=['w']*10+['tab:green']*4,legend=False)\n",
    "    \n",
    "    ax.set_xlabel(xlabel)\n",
    "    \n",
    "def calc_seq_prop(df,r,name,nu_model,SPR_model):\n",
    "    features_nu = ['scd','shd','kappa','fcr','mean_lambda']\n",
    "    features_nu_WT = ['scd_WT','shd_WT','kappa_WT','fcr_WT','mean_lambda_WT']\n",
    "    features_spr = ['scd','shd','mean_lambda']\n",
    "    features_spr_WT = ['scd_WT','shd_WT','mean_lambda_WT']\n",
    "    \n",
    "    fasta = list(df.loc[name].fasta).copy()\n",
    "    fasta_WT = list(df.loc[name].fasta_WT).copy()\n",
    "    fasta_kappa = fasta.copy()\n",
    "    fasta_kappa_WT = fasta_WT.copy()\n",
    "    \n",
    "    N = len(fasta)\n",
    "    N_WT = len(fasta_WT)\n",
    "    \n",
    "    df.loc[name,'mean_lambda'] = np.mean(r.loc[fasta].lambdas)\n",
    "    df.loc[name,'mean_lambda_WT'] = np.mean(r.loc[fasta_WT].lambdas)\n",
    "    \n",
    "    #########\n",
    "    \n",
    "    pairs = np.array(list(itertools.combinations(fasta,2)))\n",
    "    pairs_indices = np.array(list(itertools.combinations(range(N),2)))\n",
    "    # calculate sequence separations\n",
    "    ij_dist = np.diff(pairs_indices,axis=1).flatten().astype(float)\n",
    "    # calculate lambda sums\n",
    "    ll = r.lambdas.loc[pairs[:,0]].values+r.lambdas.loc[pairs[:,1]].values\n",
    "    # calculate SHD\n",
    "    beta = -1\n",
    "    df.loc[name,'shd'] = np.sum(ll*np.power(np.abs(ij_dist),beta))/N\n",
    "    \n",
    "    # fix charges\n",
    "    if df.loc[name,'first'] == 1:\n",
    "        r.loc['X'] = r.loc[fasta[0]]\n",
    "        r.loc['X','q'] = r.loc[fasta[0],'q'] + 1.\n",
    "        fasta[0] = 'X'\n",
    "        if r.loc['X','q'] > 0:\n",
    "            fasta_kappa[0] = 'K'\n",
    "        else:\n",
    "            fasta_kappa[0] = 'A'\n",
    "    if df.loc[name,'last'] == df.loc[name,'N_FL']:\n",
    "        r.loc['Z'] = r.loc[fasta[-1]]\n",
    "        r.loc['Z','q'] = r.loc[fasta[-1],'q'] - 1.\n",
    "        fasta[-1] = 'Z'\n",
    "        if r.loc['Z','q'] < 0:\n",
    "            fasta_kappa[-1] = 'D'\n",
    "        else:\n",
    "            fasta_kappa[-1] = 'A'\n",
    "    \n",
    "    pairs = np.array(list(itertools.combinations(fasta,2)))\n",
    "    # calculate charge products\n",
    "    qq = r.q.loc[pairs[:,0]].values*r.q.loc[pairs[:,1]].values\n",
    "    # calculate SCD\n",
    "    df.loc[name,'scd'] = np.sum(qq*np.sqrt(ij_dist))/N\n",
    "    SeqOb = SequenceParameters(''.join(fasta_kappa))\n",
    "    kappa = SeqOb.get_kappa()\n",
    "    df.loc[name,'kappa'] = 0 if kappa==-1 else kappa\n",
    "    df.loc[name,'fcr'] = r.q.loc[list(fasta)].abs().mean()\n",
    "    df.loc[name,'ncpr'] = r.q.loc[list(fasta)].mean()\n",
    "    \n",
    "    #########\n",
    "    \n",
    "    pairs = np.array(list(itertools.combinations(fasta_WT,2)))\n",
    "    pairs_indices = np.array(list(itertools.combinations(range(N_WT),2)))\n",
    "    # calculate sequence separations\n",
    "    ij_dist = np.diff(pairs_indices,axis=1).flatten().astype(float)\n",
    "    # calculate lambda sums\n",
    "    ll = r.lambdas.loc[pairs[:,0]].values+r.lambdas.loc[pairs[:,1]].values\n",
    "    # calculate SHD\n",
    "    beta = -1\n",
    "    df.loc[name,'shd_WT'] = np.sum(ll*np.power(np.abs(ij_dist),beta))/N_WT\n",
    "    \n",
    "    # fix charges\n",
    "    if df.loc[name,'first'] == 1:\n",
    "        r.loc['X'] = r.loc[fasta_WT[0]]\n",
    "        r.loc['X','q'] = r.loc[fasta_WT[0],'q'] + 1.\n",
    "        fasta_WT[0] = 'X'\n",
    "        if r.loc['X','q'] > 0:\n",
    "            fasta_kappa_WT[0] = 'K'\n",
    "        else:\n",
    "            fasta_kappa_WT[0] = 'A'\n",
    "    if df.loc[name,'last'] == df.loc[name,'N_FL']:\n",
    "        r.loc['Z'] = r.loc[fasta_WT[-1]]\n",
    "        r.loc['Z','q'] = r.loc[fasta_WT[-1],'q'] - 1.\n",
    "        fasta_WT[-1] = 'Z'\n",
    "        if r.loc['Z','q'] < 0:\n",
    "            fasta_kappa_WT[-1] = 'D'\n",
    "        else:\n",
    "            fasta_kappa_WT[-1] = 'A'\n",
    "    \n",
    "    pairs = np.array(list(itertools.combinations(fasta_WT,2)))\n",
    "    # calculate charge products\n",
    "    qq = r.q.loc[pairs[:,0]].values*r.q.loc[pairs[:,1]].values\n",
    "    # calculate SCD\n",
    "    df.loc[name,'scd_WT'] = np.sum(qq*np.sqrt(ij_dist))/N\n",
    "    SeqOb = SequenceParameters(''.join(fasta_kappa_WT))\n",
    "    kappa = SeqOb.get_kappa()\n",
    "    df.loc[name,'kappa_WT'] = 0 if kappa==-1 else kappa\n",
    "    df.loc[name,'fcr_WT'] = r.q.loc[list(fasta_WT)].abs().mean()\n",
    "    df.loc[name,'ncpr_WT'] = r.q.loc[list(fasta_WT)].mean()\n",
    "            \n",
    "    df.loc[name,'nu'] = nu_model.predict(df.loc[name,features_nu].values.reshape(1, -1))\n",
    "    df.loc[name,'nu_WT'] = nu_model.predict(df.loc[name,features_nu_WT].values.reshape(1, -1))\n",
    "    df.loc[name,'SPR'] = SPR_model.predict(df.loc[name,features_spr].values.reshape(1, -1))\n",
    "    df.loc[name,'SPR_WT'] = SPR_model.predict(df.loc[name,features_spr_WT].values.reshape(1, -1))\n",
    "    \n",
    "def format_scientific(x):\n",
    "    a = f'{x:.0e}'.split('e')[0]\n",
    "    b = int(f'{x:.0e}'.split('e')[1])\n",
    "    return a+'\\\\times'+'10^{'+f'{b:d}'+'}'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28d27304",
   "metadata": {},
   "source": [
    "#### Generate sequences of missense variants from ClinVar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b35de58f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load dataframes\n",
    "df_variants = pd.DataFrame()\n",
    "df_idrome = pd.read_csv('IDRome_DB.csv',index_col=0)\n",
    "r = pd.read_csv('md_simulations/data/residues.csv').set_index('one',drop=False)\n",
    "clinvar_info = pd.read_csv('clinvar_fmug_cdcode/data/idr_fragments_clinvar_info.csv',index_col='idr_fragment')\n",
    "clinvar_info.Clinvar_ID = clinvar_info.Clinvar_ID.apply(lambda x: literal_eval(x))\n",
    "clinvar_info.Clinvar_signifiance = clinvar_info.Clinvar_signifiance.apply(lambda x: literal_eval(x))\n",
    "clinvar_info.variants = clinvar_info.variants.apply(lambda x: literal_eval(x))\n",
    "\n",
    "# Load pLDDT scores\n",
    "pLDDT = pd.read_csv('idr_selection/idr.csv.gz',header=0,sep=';')\n",
    "pLDDT.sort_values('uniprot',inplace=True)\n",
    "pLDDT['seq_name'] = pLDDT.uniprot+'_'+pLDDT['first'].apply(\n",
    "    lambda x : '{:g}'.format(x))+'_'+pLDDT['last'].apply(lambda x : '{:g}'.format(x))\n",
    "pLDDT['pLDDT_w20'] = pLDDT['pLDDT_w20'].apply(lambda x : 100*np.array(eval(x.replace(':',','))))\n",
    "pLDDT.set_index('seq_name',inplace=True)\n",
    "\n",
    "# Generate dataframe with sequences of variants\n",
    "idrs_w_variants = clinvar_info[clinvar_info.variants.map(len)>0].index\n",
    "for name in idrs_w_variants:\n",
    "    fasta_WT = df_idrome.loc[name].fasta\n",
    "    for x,s in zip(clinvar_info.loc[name,'variants'],clinvar_info.loc[name,'Clinvar_signifiance']):\n",
    "        fasta_var = fasta_WT\n",
    "        res_num_var = int(x[1:-1])-df_idrome.loc[name,'first']\n",
    "        fasta_var = fasta_WT[:res_num_var] + x[-1] + fasta_WT[res_num_var+1:]\n",
    "        df_variants.loc[name+'_'+x,'fasta'] = fasta_var\n",
    "        df_variants.loc[name+'_'+x,'fasta_WT'] = fasta_WT\n",
    "        df_variants.loc[name+'_'+x,'significance'] = s\n",
    "        df_variants.loc[name+'_'+x,'WT'] = name\n",
    "        df_variants.loc[name+'_'+x,'pLDDT'] = pLDDT.loc[name,'pLDDT_w20'][res_num_var]\n",
    "        df_variants.loc[name+'_'+x,'fdomain'] = df_idrome.loc[name,'fdomain']\n",
    "        df_variants.loc[name+'_'+x,'first'] = df_idrome.loc[name,'first']\n",
    "        df_variants.loc[name+'_'+x,'last'] = df_idrome.loc[name,'last']\n",
    "        df_variants.loc[name+'_'+x,'N_FL'] = df_idrome.loc[name,'N_FL']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aad3dd11",
   "metadata": {},
   "source": [
    "#### Calculate Flory scaling exponents for WT and variants using the SVR model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c2aa10fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "nu_model = load('svr_models/svr_model_nu.joblib') \n",
    "SPR_model = load('svr_models/svr_model_SPR.joblib') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5520ab27",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.isfile('clinvar_fmug_cdcode/data/missense_variants.csv.gz'):\n",
    "    for ndx in df_variants.index:\n",
    "        calc_seq_prop(df_variants,r,ndx,nu_model,SPR_model)\n",
    "    df_variants['Delta_nu'] = df_variants['nu'] - df_variants['nu_WT']\n",
    "    df_variants['Delta_SPR'] = df_variants['SPR'] - df_variants['SPR_WT']\n",
    "    df_variants['nu_sim'] = df_variants.WT.apply(lambda x : df_idrome.loc[x].nu)\n",
    "    df_variants['SPR_sim'] = df_variants.WT.apply(lambda x : df_idrome.loc[x].SPR)\n",
    "    df_variants.to_csv('clinvar_fmug_cdcode/data/missense_variants.csv.gz')\n",
    "else:\n",
    "    df_variants = pd.read_csv('clinvar_fmug_cdcode/data/missense_variants.csv.gz',index_col=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9160180",
   "metadata": {},
   "source": [
    "#### Number of pathogenic and benign variants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2d7476df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2888, 15557)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_variants.query('significance == \"pathogenic\"').shape[0],df_variants.query('significance == \"benign\"').shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea9c0610",
   "metadata": {},
   "source": [
    "#### Number of IDRs and proteins harbouring variants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c888fd8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6217, 4292)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_variants.WT.unique().size,df_idrome.loc[df_variants.WT.unique()].UniProt_ID.unique().size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "efd7b461",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.22157673390833274"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_variants.WT.unique().size/df_idrome.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2639587",
   "metadata": {},
   "source": [
    "#### Count benign and pathogenic variants per IDR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1fd4c47b",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_idrome['n_benign'] = clinvar_info.Clinvar_signifiance.apply(lambda x: x.count('benign'))\n",
    "df_idrome['n_pathogenic'] = clinvar_info.Clinvar_signifiance.apply(lambda x: x.count('pathogenic'))\n",
    "df_idrome['n_variants'] = df_idrome['n_benign'] + df_idrome['n_pathogenic']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05e6bf4f",
   "metadata": {},
   "source": [
    "#### Extract number of publications per gene from FMUG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9955f7cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "gene_n_pubs = pd.read_csv('clinvar_fmug_cdcode/data/fmug_data.csv.gz',index_col=0).n_pubs\n",
    "df_idrome['n_pubs'] = df_idrome.gene_name.apply(lambda x : gene_n_pubs[x] if x in gene_n_pubs.index else 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4571af01",
   "metadata": {},
   "source": [
    "#### Fig. 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "b38b4a52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Families with p-value < 3.28e-06 and alpha ratio > 1.5\n",
      "(1137, 17) (15235, 17)\n",
      "mean error on nu 0.008033048158897566\n",
      "15557 2888\n",
      "KIF21B alpha ratio 1.534861212573633\n",
      "SHC2 alpha ratio 4.986473672003258\n",
      "LIMK1 alpha ratio 1.8599173431431324\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 660x370 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(6.6,3.7))\n",
    "ax1 = plt.subplot2grid( (2,6), (0,0), rowspan=1, colspan=3 )\n",
    "ax2 = plt.subplot2grid( (2,6), (0,3), rowspan=1, colspan=1 )\n",
    "ax3 = plt.subplot2grid( (2,6), (0,4), rowspan=1, colspan=1 )\n",
    "ax4 = plt.subplot2grid( (2,6), (0,5), rowspan=1, colspan=1 )\n",
    "ax5 = plt.subplot2grid( (2,6), (1,0), rowspan=1, colspan=2 )\n",
    "ax6 = plt.subplot2grid( (2,6), (1,2), rowspan=1, colspan=2 )\n",
    "ax7 = plt.subplot2grid( (2,6), (1,4), rowspan=1, colspan=2 )\n",
    "plt.rc('font', **{'family':'sans-serif','sans-serif':['Arial'], 'size': 6})\n",
    "\n",
    "families = pd.read_pickle('idr_orthologs/data/conf_buffering_families.pkl')\n",
    "p_values_threshold = 0.05/families.shape[0]\n",
    "\n",
    "print(f'Families with p-value < {p_values_threshold:.3g} and alpha ratio > 1.5'.format(p_values_threshold))\n",
    "print(families.query(f'nu_pcorr_p<3.282e-6 and nu_alpha_ratio>1.5').shape,families.shape)\n",
    "\n",
    "df_conf_buffering = pd.read_csv('md_simulations/data/conf_buffering/conf_buffering_md_data.csv',index_col=0)\n",
    "print('mean error on nu',df_conf_buffering.nu_err.mean())\n",
    "\n",
    "nu_benign = df_variants.query('significance == \"benign\"').nu_sim\n",
    "SPR_benign = df_variants.query('significance == \"benign\"').SPR_sim\n",
    "pLDDT_benign = df_variants.query('significance == \"benign\"').pLDDT\n",
    "nu_pathogenic = df_variants.query('significance == \"pathogenic\"').nu_sim\n",
    "SPR_pathogenic = df_variants.query('significance == \"pathogenic\"').SPR_sim\n",
    "pLDDT_pathogenic = df_variants.query('significance == \"pathogenic\"').pLDDT\n",
    "\n",
    "print(nu_benign.size,nu_pathogenic.size)\n",
    "\n",
    "bin_width = .02\n",
    "bins = np.arange(9.4, 11.5,bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "h = np.histogram(SPR_pathogenic,bins=bins,density=True)[0]\n",
    "ax5.bar(x,h,alpha=.8,width=bin_width,color=pt_colors['grey'],\n",
    "           label='Pathogenic')\n",
    "\n",
    "ax5.hist(SPR_benign,bins,density=True,histtype='step',\n",
    "         color='k',zorder=1,label='Benign')\n",
    "\n",
    "dof = f'DoF: {calc_dof(SPR_pathogenic, SPR_benign):,.0f}'\n",
    "statistic, p_less = stats.brunnermunzel(SPR_pathogenic, SPR_benign, alternative='less')\n",
    "cohensd, cohensd_se = bootstrapped_cohens_d(SPR_pathogenic, SPR_benign, 100000)\n",
    "cohensd_label = f\"Cohen's $d$: {cohensd:.2f}±{cohensd_se:.2f}\"\n",
    "p_less_label = f'$P={format_scientific(p_less)}$' if p_less >= 1e-10 else '$P<1\\\\times10^{-10}$'\n",
    "leg = ax5.legend(handlelength=1,frameon=False,\n",
    "                 title=cohensd_label+'\\n'+dof+'\\n'+p_less_label,\n",
    "                 markerfirst=False,alignment='right',borderpad=0)\n",
    "leg.get_title().set_ha('right') \n",
    "#########\n",
    "\n",
    "bin_width = 2\n",
    "bins = np.arange(19.5, 90,bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "h = np.histogram(pLDDT_pathogenic,bins=bins,density=True)[0]\n",
    "ax6.bar(x,h,alpha=.8,width=bin_width,color=pt_colors['grey'],\n",
    "           label='Pathogenic')\n",
    "\n",
    "ax6.hist(pLDDT_benign,bins,density=True,histtype='step',\n",
    "         color='k',zorder=1,label='Benign')\n",
    "\n",
    "dof = f'DoF: {calc_dof(pLDDT_pathogenic,pLDDT_benign):,.0f}'\n",
    "statistic, p_greater = stats.brunnermunzel(pLDDT_pathogenic, pLDDT_benign, alternative='greater')\n",
    "cohensd, cohensd_se = bootstrapped_cohens_d(pLDDT_pathogenic, pLDDT_benign, 100000)\n",
    "cohensd_label = f\"Cohen's $d$: {cohensd:.2f}±{cohensd_se:.2f}\"\n",
    "p_greater_label = f'$P={format_scientific(p_greater)}$' if p_greater >= 1e-10 else '$P<1\\\\times10^{-10}$'\n",
    "leg = ax6.legend(handlelength=1,frameon=False,\n",
    "                 title=cohensd_label+'\\n'+dof+'\\n'+p_greater_label,\n",
    "                 markerfirst=False,alignment='right',borderpad=0)\n",
    "leg.get_title().set_ha('right') \n",
    "\n",
    "############\n",
    "\n",
    "bin_width = .006\n",
    "bins = np.arange(0.05, .74, bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "h = np.histogram(nu_pathogenic,bins=bins,density=True)[0]\n",
    "ax7.bar(x,h,alpha=.8,width=bin_width,color=pt_colors['grey'],\n",
    "           label='Pathogenic')\n",
    "\n",
    "ax7.hist(nu_benign,bins,density=True,histtype='step',\n",
    "         color='k',zorder=1,label='Benign')\n",
    "\n",
    "dof = f'DoF: {calc_dof(nu_pathogenic, nu_benign):,.0f}'\n",
    "statistic, p_less = stats.brunnermunzel(nu_pathogenic, nu_benign, alternative='less')\n",
    "cohensd, cohensd_se = bootstrapped_cohens_d(nu_pathogenic, nu_benign, 100000)\n",
    "cohensd_label = f\"Cohen's $d$: {cohensd:.2f}±{cohensd_se:.2f}\"\n",
    "p_less_label = f'$P={format_scientific(p_less)}$' if p_less >= 1e-10 else '$P<1\\\\times10^{-10}$'\n",
    "leg = ax7.legend(handlelength=1,frameon=False,loc='upper right',\n",
    "                 title=cohensd_label+'\\n'+dof+'\\n'+p_less_label,\n",
    "                 markerfirst=False,alignment='right',borderpad=0)\n",
    "leg.get_title().set_ha('right') \n",
    "\n",
    "#########\n",
    "\n",
    "im = ax1.scatter(families.nu_pcorr, \n",
    "            -np.log10(families.nu_pcorr_p), marker='o', s=4, \n",
    "         lw=0, c=families.nu_alpha_ratio,vmin=1,vmax=2)\n",
    "\n",
    "ax1.axhline(-np.log10(p_values_threshold),ls='--',color='k',lw=.5)\n",
    "\n",
    "divider = make_axes_locatable(ax1)\n",
    "cax = divider.new_vertical(size=\"{:.1f}%\".format(5), pad=.1)\n",
    "fig.add_axes(cax)\n",
    "cb = fig.colorbar(im, cax=cax, orientation='horizontal',\n",
    "                label=r'$\\alpha$ / $\\alpha_\\mathrm{ref}$')\n",
    "cax.xaxis.set_label_position('top'); cax.xaxis.set_ticks_position('top')\n",
    "\n",
    "ax1.set_xlabel('Pearson $r$')\n",
    "ax1.set_ylabel(\"$-\\log_{10}(P\\;\\mathrm{value})$\")\n",
    "\n",
    "############\n",
    "\n",
    "for name,ax,title in zip(['O75037_811_918','P98077_303_484','P53667_251_339'],\n",
    "                   [ax2,ax3,ax4],['KIF21B','SHC2','LIMK1']):\n",
    "    \n",
    "    print(title,'alpha ratio',families.loc[name].nu_alpha_ratio)\n",
    "\n",
    "    example = families.loc[name]  \n",
    "    # Plotting correlation\n",
    "    ax.scatter(example.N[np.argsort(example.N)], example.nu[np.argsort(example.N)], \n",
    "            s=8, c=[example.nu_alpha_ratio]*example.N.size, vmin=1, vmax=2, edgecolors='k', lw=.5)\n",
    "    \n",
    "    md_data = df_conf_buffering[df_conf_buffering.human==name]\n",
    "    alpha, _ = np.polyfit(md_data.N,md_data.nu, 1)\n",
    "    ax.scatter(md_data.N,md_data.nu,marker='s',\n",
    "            s=8, c=[alpha/example.nu_alpha_ref]*example.N.size, vmin=1, vmax=2, edgecolors='k', lw=.5)\n",
    "    ax.errorbar(md_data.N,md_data.nu,yerr=md_data.nu_err,ms=0,lw=0,zorder=0,\n",
    "             elinewidth=.5,capsize=2,capthick=.5,color='k')\n",
    "  \n",
    "    N = np.array([md_data.N.min(), md_data.N.max()])\n",
    "    slope, intersect = np.polyfit(md_data.N, md_data.nu, 1)\n",
    "    ax.plot(N, N*slope+intersect, c='k', ls='--', label=fr'$r={example.nu_pcorr:.2f}$', lw=.5)\n",
    "    \n",
    "    ax1.scatter(example.nu_pcorr, \n",
    "            -np.log10(example.nu_pcorr_p), marker='o', s=20, fc='None',\n",
    "         lw=1, ec='k')\n",
    "    \n",
    "    if title == 'KIF21B':\n",
    "        ax1.annotate(title,xy=(example.nu_pcorr+.07,-np.log10(example.nu_pcorr_p)+1))\n",
    "    else:\n",
    "        ax1.annotate(title,xy=(example.nu_pcorr+.15,-np.log10(example.nu_pcorr_p)))\n",
    "        \n",
    "    ax.set_title(title)\n",
    "    ax.set_ylabel('$\\\\nu$')\n",
    "    ax.set_xlabel('$N$')\n",
    "    \n",
    "############\n",
    "\n",
    "ax1.set_xlim(-1,1)\n",
    "ax5.set_xlim(9.7,10.6)\n",
    "ax6.set_ylim(0,.075)\n",
    "ax7.set_xlim(.4,.63)\n",
    "ax7.set_ylim(0,30)\n",
    "\n",
    "ax5.set_xlabel(r'$S_\\mathrm{conf}$ / $N$ of the WT ($k_B$)')\n",
    "ax6.set_xlabel(r'pLDDT Score of the Substituted Residue')\n",
    "ax7.set_xlabel('$\\\\nu$ of the WT')\n",
    "ax5.set_ylabel('Normalized Distribution')\n",
    "ax6.set_ylabel('Normalized Distribution')\n",
    "ax7.set_ylabel('Normalized Distribution')\n",
    "\n",
    "fig.text(0.01, .92, 'a', fontsize=10)\n",
    "fig.text(0.52, .92, 'b', fontsize=10)\n",
    "fig.text(0.69, .92, 'c', fontsize=10)\n",
    "fig.text(0.85, .92, 'd', fontsize=10)\n",
    "fig.text(0.01, .45, 'e', fontsize=10)\n",
    "fig.text(0.35, .45, 'f', fontsize=10)\n",
    "fig.text(0.67, .45, 'g', fontsize=10)\n",
    "\n",
    "plt.tight_layout()\n",
    "fig.savefig('figs/fig5.pdf',dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98b567f7",
   "metadata": {},
   "source": [
    "#### Analysis of frameshift variants in C-terminal IDRs identified by Mensah et al. (DOI: 10.1038/s41586-022-05682-1)\n",
    "The list of variants with ClinVar significance annotations were obtained from https://zenodo.org/record/7311150/files/MasterTable_wNMD_wVariantDisease_wRK_WHidrophobic_wNLS_wTransmembrane_220608_Full.csv.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f91ddcd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "url = \"\"\"https://zenodo.org/record/7311150/files/MasterTable_wNMD_wVariantDisease_\n",
    "wRK_WHidrophobic_wNLS_wTransmembrane_220608_Full.csv.zip\"\"\".replace('\\n','')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7015e4b7",
   "metadata": {},
   "source": [
    "#### Load table and select IDRs with WT and variant sequence lengths $\\geq30$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "ef64d5cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_frameshift = pd.read_csv(url, low_memory=False)\n",
    "df_frameshift = df_frameshift.query('SeqType == \"Frameshift\"')\n",
    "df_frameshift = df_frameshift.rename({'IDRseq':'fasta', 'TrueIDRstart':'first',\n",
    "                      'WTIDRseq':'fasta_WT', 'WTFullLength':'N_FL'},axis=1)\n",
    "df_frameshift['N_WT'] = df_frameshift.fasta_WT.apply(len)\n",
    "df_frameshift['N'] = df_frameshift.fasta.apply(len)\n",
    "df_frameshift = df_frameshift.query('N >= 30 and N_WT >= 30')\n",
    "df_frameshift['last'] = df_frameshift['N_FL']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "326cbc1b",
   "metadata": {},
   "source": [
    "#### Calculate Flory scaling exponents for WT and variants using the SVR model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "399be126",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.isfile('clinvar_fmug_cdcode/data/frameshift_variants.csv.gz'):\n",
    "    for ndx in df_frameshift.index:\n",
    "        calc_seq_prop(df_frameshift,r,ndx,nu_model,SPR_model)\n",
    "    df_frameshift['Delta_nu'] = df_frameshift['nu'] - df_frameshift['nu_WT']\n",
    "    df_frameshift['Delta_SPR'] = df_frameshift['SPR'] - df_frameshift['SPR_WT']\n",
    "    df_frameshift.to_csv('clinvar_fmug_cdcode/data/frameshift_variants.csv.gz')\n",
    "else:\n",
    "    df_frameshift = pd.read_csv('clinvar_fmug_cdcode/data/frameshift_variants.csv.gz',index_col=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0265d64",
   "metadata": {},
   "source": [
    "#### Find IDRs in pathogenic variants in IDRs with low conformational entropy per residue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "4fbeb1a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "seq_name\n",
       "P02462_1_1436                     Collagen alpha-1(IV) chain\n",
       "P08572_1_1484                     Collagen alpha-2(IV) chain\n",
       "P09651_187_372    Heterogeneous nuclear ribonucleoprotein A1\n",
       "P13645_1_151                 Keratin, type I cytoskeletal 10\n",
       "P29400_1_1456                     Collagen alpha-5(IV) chain\n",
       "P35527_1_157                  Keratin, type I cytoskeletal 9\n",
       "P35637_1_285                         RNA-binding protein FUS\n",
       "P53420_1_1456                     Collagen alpha-4(IV) chain\n",
       "Name: protein_name, dtype: object"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_variants['is_cys'] = df_variants.index.map(lambda x :\n",
    "                1 if ('_C' in x or x[-1]=='C') else 0)\n",
    "\n",
    "df_idrome_domain = pd.read_csv('IDRome_DB_Domains.csv',index_col=0)\n",
    "indices = df_variants.query('significance == \"pathogenic\" and SPR <= 9.8').WT.unique()\n",
    "df_var_domains = df_idrome_domain.loc[indices,['Descriptions','fdomain','nu']]\n",
    "df_var_domains['number_C_variants'] = df_variants[df_variants.WT.isin(df_var_domains.index)][\n",
    "                        ['WT','is_cys']].groupby('WT').sum()\n",
    "df_idrome.loc[df_var_domains.index,'protein_name']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f4a4028",
   "metadata": {},
   "source": [
    "#### Find IDRs with pathogenic variants in folded domains\n",
    "The N-terminal domain of Neurogenic locus notch homolog protein 3 has 110 pathogenic substitutions to or from cystein residues which may be involved in EGF-like domains. With a scaling exponent of 0.434, this IDR alone significantly increases the significance of the association between pathogenicity and compaction. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "2da60876",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Descriptions</th>\n",
       "      <th>fdomain</th>\n",
       "      <th>nu</th>\n",
       "      <th>number_C_variants</th>\n",
       "      <th>number_variants</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>seq_name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>P51610_397_1822</th>\n",
       "      <td>Fibronectin type-III 2</td>\n",
       "      <td>0.017532</td>\n",
       "      <td>0.534</td>\n",
       "      <td>1</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q9UM47_1_1399</th>\n",
       "      <td>EGF-like 34</td>\n",
       "      <td>0.027162</td>\n",
       "      <td>0.434</td>\n",
       "      <td>110</td>\n",
       "      <td>148</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q9UL68_1_1057</th>\n",
       "      <td>Zinc finger</td>\n",
       "      <td>0.040681</td>\n",
       "      <td>0.255</td>\n",
       "      <td>1</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q8IZC6_227_1666</th>\n",
       "      <td>Collagen-like 16</td>\n",
       "      <td>0.040972</td>\n",
       "      <td>0.514</td>\n",
       "      <td>2</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q9NQX1_1_316</th>\n",
       "      <td>Zinc finger</td>\n",
       "      <td>0.066456</td>\n",
       "      <td>0.457</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>P42768_307_502</th>\n",
       "      <td>WH2</td>\n",
       "      <td>0.086735</td>\n",
       "      <td>0.482</td>\n",
       "      <td>0</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q13402_787_1000</th>\n",
       "      <td>IQ 5</td>\n",
       "      <td>0.093458</td>\n",
       "      <td>0.152</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>P55895_341_527</th>\n",
       "      <td>Zinc finger</td>\n",
       "      <td>0.363636</td>\n",
       "      <td>0.268</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                           Descriptions   fdomain     nu  number_C_variants  \\\n",
       "seq_name                                                                      \n",
       "P51610_397_1822  Fibronectin type-III 2  0.017532  0.534                  1   \n",
       "Q9UM47_1_1399               EGF-like 34  0.027162  0.434                110   \n",
       "Q9UL68_1_1057               Zinc finger  0.040681  0.255                  1   \n",
       "Q8IZC6_227_1666        Collagen-like 16  0.040972  0.514                  2   \n",
       "Q9NQX1_1_316                Zinc finger  0.066456  0.457                  2   \n",
       "P42768_307_502                      WH2  0.086735  0.482                  0   \n",
       "Q13402_787_1000                    IQ 5  0.093458  0.152                  0   \n",
       "P55895_341_527              Zinc finger  0.363636  0.268                  1   \n",
       "\n",
       "                 number_variants  \n",
       "seq_name                          \n",
       "P51610_397_1822               16  \n",
       "Q9UM47_1_1399                148  \n",
       "Q9UL68_1_1057                 12  \n",
       "Q8IZC6_227_1666               32  \n",
       "Q9NQX1_1_316                   4  \n",
       "P42768_307_502                 9  \n",
       "Q13402_787_1000                4  \n",
       "P55895_341_527                 8  "
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_variants['is_cys'] = df_variants.index.map(lambda x :\n",
    "                1 if ('_C' in x or x[-1]=='C') else 0)\n",
    "\n",
    "df_idrome_domain = pd.read_csv('IDRome_DB_Domains.csv',index_col=0)\n",
    "indices = df_variants.query('significance == \"pathogenic\" and fdomain > 0 and nu <= 0.45').WT.unique()\n",
    "df_var_domains = df_idrome_domain.loc[indices,['Descriptions','fdomain','nu']]\n",
    "df_var_domains['number_C_variants'] = df_variants[df_variants.WT.isin(df_var_domains.index)][\n",
    "                        ['WT','is_cys']].groupby('WT').sum()\n",
    "df_var_domains['number_variants'] = df_variants[df_variants.WT.isin(df_var_domains.index)][\n",
    "                        ['WT','is_cys']].groupby('WT').count()\n",
    "df_var_domains.sort_values('fdomain')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2175086a",
   "metadata": {},
   "source": [
    "#### How many pathogenic substitutions involve cysteins?\n",
    "Out of 5,815 pathogenic variants, 691 (11.9%) are substitutions to or from cystein residues. Excluding IDRs containing domain annotations, the fraction of pathogenic variants involving cysteins decreases to 6.3%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "e7b721e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5815\n",
      "691\n",
      "11.883061049011177\n"
     ]
    }
   ],
   "source": [
    "indices = df_variants.query('significance == \"pathogenic\"').WT.unique()\n",
    "pathogenic_variants = np.array(clinvar_info.loc[indices].variants.sum())\n",
    "print(pathogenic_variants.size)\n",
    "print(np.sum(['C' in i for i in pathogenic_variants]))\n",
    "print(np.sum(['C' in i for i in pathogenic_variants])/pathogenic_variants.size*100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "e38fce43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3767\n",
      "238\n",
      "6.318024953543934\n"
     ]
    }
   ],
   "source": [
    "indices = df_variants.query('significance == \"pathogenic\" and fdomain == 0').WT.unique()\n",
    "pathogenic_variants = np.array(clinvar_info.loc[indices].variants.sum())\n",
    "print(pathogenic_variants.size)\n",
    "print(np.sum(['C' in i for i in pathogenic_variants]))\n",
    "print(np.sum(['C' in i for i in pathogenic_variants])/pathogenic_variants.size*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc8785b6",
   "metadata": {},
   "source": [
    "#### Extdended Data Fig. 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "8b3225fa",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/y_/2x90pfvj0138gctc5qx9196m0000gn/T/ipykernel_13533/2294929661.py:190: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df.loc[:,'nu_intervals'] = intervals.values\n",
      "/var/folders/y_/2x90pfvj0138gctc5qx9196m0000gn/T/ipykernel_13533/2294929661.py:215: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df.loc[:,'nu_intervals'] = intervals.values\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 660x500 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ((ax1,ax2,ax3),(ax4,ax5,ax6),(ax7,ax8,ax9)) = plt.subplots(3, 3, \n",
    "                                                sharex=False, sharey=False, figsize=(6.6,5))\n",
    "plt.rc('font', **{'family':'sans-serif','sans-serif':['Arial'], 'size': 6})\n",
    "\n",
    "nu_benign = df_variants.query('significance == \"benign\" and fdomain == 0').nu_sim\n",
    "SPR_benign = df_variants.query('significance == \"benign\" and fdomain == 0').SPR_sim\n",
    "pLDDT_benign = df_variants.query('significance == \"benign\" and fdomain == 0').pLDDT\n",
    "nu_pathogenic = df_variants.query('significance == \"pathogenic\" and fdomain == 0').nu_sim\n",
    "SPR_pathogenic = df_variants.query('significance == \"pathogenic\" and fdomain == 0').SPR_sim\n",
    "pLDDT_pathogenic = df_variants.query('significance == \"pathogenic\" and fdomain == 0').pLDDT\n",
    "\n",
    "bin_width = .02\n",
    "bins = np.arange(9.4, 11.5,bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "h = np.histogram(SPR_pathogenic,bins=bins,density=True)[0]\n",
    "ax1.bar(x,h,alpha=.8,width=bin_width,color=pt_colors['grey'],\n",
    "           label='Pathogenic')\n",
    "\n",
    "ax1.hist(SPR_benign,bins,density=True,histtype='step',\n",
    "         color='k',zorder=1,label='Benign')\n",
    "\n",
    "statistic, p_less = stats.brunnermunzel(SPR_pathogenic, SPR_benign, alternative='less')\n",
    "dof = f'DoF: {calc_dof(SPR_pathogenic, SPR_benign):,.0f}'\n",
    "cohensd, cohensd_se = bootstrapped_cohens_d(SPR_pathogenic, SPR_benign, 100000)\n",
    "cohensd_label = f\"Cohen's $d$: {cohensd:.2f}±{cohensd_se:.2f}\"\n",
    "p_less_label = f'$P={format_scientific(p_less)}$' if p_less >= 1e-10 else '$P<1\\\\times10^{-10}$'\n",
    "leg = ax1.legend(handlelength=1,frameon=False,\n",
    "                 title='$f_\\mathrm{domain}=0$\\n'+cohensd_label+'\\n'+dof+'\\n'+p_less_label,\n",
    "                 markerfirst=False,alignment='right',borderpad=0)\n",
    "leg.get_title().set_ha('right') \n",
    "\n",
    "#########\n",
    "\n",
    "bin_width = 2\n",
    "bins = np.arange(19.5, 90,bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "h = np.histogram(pLDDT_pathogenic,bins=bins,density=True)[0]\n",
    "ax2.bar(x,h,alpha=.8,width=bin_width,color=pt_colors['grey'],\n",
    "           label='Pathogenic')\n",
    "\n",
    "ax2.hist(pLDDT_benign,bins,density=True,histtype='step',\n",
    "         color='k',zorder=1,label='Benign')\n",
    "\n",
    "dof = f'\\nDoF: {calc_dof(pLDDT_pathogenic, pLDDT_benign):,.0f}'\n",
    "statistic, p_greater = stats.brunnermunzel(pLDDT_pathogenic, pLDDT_benign, alternative='greater')\n",
    "cohensd, cohensd_se = bootstrapped_cohens_d(pLDDT_pathogenic, pLDDT_benign, 100000)\n",
    "cohensd_label = f\"Cohen's $d$: {cohensd:.2f}±{cohensd_se:.2f}\"\n",
    "p_greater_label = f'$P={format_scientific(p_greater)}$' if p_greater >= 1e-10 else '$P<1\\\\times10^{-10}$'\n",
    "leg = ax2.legend(handlelength=1,frameon=False,\n",
    "                 title='$f_\\mathrm{domain}=0$\\n'+cohensd_label+dof+'\\n'+p_greater_label,\n",
    "                 markerfirst=False,alignment='right',borderpad=0)\n",
    "leg.get_title().set_ha('right') \n",
    "\n",
    "############\n",
    "\n",
    "bin_width = .006\n",
    "bins = np.arange(0.05, .74, bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "h = np.histogram(nu_pathogenic,bins=bins,density=True)[0]\n",
    "ax3.bar(x,h,alpha=.8,width=bin_width,color=pt_colors['grey'],\n",
    "           label='Pathogenic')\n",
    "\n",
    "ax3.hist(nu_benign,bins,density=True,histtype='step',\n",
    "         color='k',zorder=1,label='Benign')\n",
    "\n",
    "dof = f'\\nDoF: {calc_dof(nu_pathogenic, nu_benign):,.0f}'\n",
    "statistic, p_less = stats.brunnermunzel(nu_pathogenic, nu_benign, alternative='less')\n",
    "cohensd, cohensd_se = bootstrapped_cohens_d(nu_pathogenic, nu_benign, 100000)\n",
    "cohensd_label = f\"Cohen's $d$: {cohensd:.2f}±{cohensd_se:.2f}\"\n",
    "p_less_label = f'$P={format_scientific(p_less)}$' if p_less >= 1e-10 else '$P<1\\\\times10^{-10}$'\n",
    "leg = ax3.legend(handlelength=1,frameon=False,\n",
    "                 title='$f_\\mathrm{domain}=0$\\n'+cohensd_label+dof+'\\n'+p_less_label,\n",
    "                 markerfirst=False,alignment='right',borderpad=0,loc='upper right')\n",
    "leg.get_title().set_ha('right') \n",
    "\n",
    "#########\n",
    "\n",
    "nu_benign = df_variants.query('significance == \"benign\" and fdomain == 0').Delta_nu\n",
    "SPR_benign = df_variants.query('significance == \"benign\" and fdomain == 0').Delta_SPR\n",
    "nu_pathogenic = df_variants.query('significance == \"pathogenic\" and fdomain == 0').Delta_nu\n",
    "SPR_pathogenic = df_variants.query('significance == \"pathogenic\" and fdomain == 0').Delta_SPR\n",
    "\n",
    "#########\n",
    "\n",
    "bin_width = .001\n",
    "bins = np.arange(-.015, .015,bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "h = np.histogram(SPR_pathogenic,bins=bins,density=True)[0]\n",
    "ax4.bar(x,h,alpha=.8,width=bin_width,color=pt_colors['grey'],\n",
    "           label='Pathogenic')\n",
    "\n",
    "ax4.hist(SPR_benign,bins,density=True,histtype='step',\n",
    "         color='k',zorder=1,label='Benign')\n",
    "\n",
    "statistic, p_greater = stats.brunnermunzel(SPR_pathogenic, SPR_benign, alternative='greater')\n",
    "dof = f'\\nDoF: {calc_dof(SPR_pathogenic, SPR_benign):,.0f}'\n",
    "cohensd, cohensd_se = bootstrapped_cohens_d(SPR_pathogenic, SPR_benign, 100000)\n",
    "cohensd_label = f\"\\nCohen's $d$:\\n{cohensd:.2f}±{cohensd_se:.2f}\"\n",
    "p_greater_label = f'$P={format_scientific(p_greater)}$' if p_greater >= 1e-10 else '$P<1\\\\times10^{-10}$'\n",
    "leg = ax4.legend(handlelength=1,frameon=False,\n",
    "           title='$f_\\mathrm{domain}=0$'+cohensd_label+dof+'\\n'+p_greater_label,\n",
    "           markerfirst=False,alignment='right',borderpad=0,loc='upper right')\n",
    "leg.get_title().set_ha('right') \n",
    "ax4.set_xlim(-.014,.015)\n",
    "\n",
    "############\n",
    "\n",
    "bin_width = .0002\n",
    "bins = np.arange(-.005, .005, bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "h = np.histogram(nu_pathogenic,bins=bins,density=True)[0]\n",
    "ax5.bar(x,h,alpha=.8,width=bin_width,color=pt_colors['grey'],\n",
    "           label='Pathogenic')\n",
    "\n",
    "ax5.hist(nu_benign,bins,density=True,histtype='step',\n",
    "         color='k',zorder=1,label='Benign')\n",
    "\n",
    "statistic, p_greater = stats.brunnermunzel(nu_pathogenic, nu_benign, alternative='greater')\n",
    "dof = f'\\nDoF: {calc_dof(nu_pathogenic, nu_benign):,.0f}'\n",
    "cohensd, cohensd_se = bootstrapped_cohens_d(nu_pathogenic, nu_benign, 100000)\n",
    "cohensd_label = f\"\\nCohen's $d$:\\n{cohensd:.2f}±{cohensd_se:.2f}\"\n",
    "p_greater_label = f'$P={format_scientific(p_greater)}$' if p_greater >= 1e-10 else '$P<1\\\\times10^{-10}$'\n",
    "leg = ax5.legend(handlelength=1,frameon=False,markerfirst=False,alignment='right',borderpad=0,\n",
    "           title='$f_\\mathrm{domain}=0$'+cohensd_label+dof+'\\n'+p_greater_label)\n",
    "leg.get_title().set_ha('right') \n",
    "\n",
    "#########\n",
    "\n",
    "nu_benign = df_frameshift.query('Pathogenic == False').Delta_nu\n",
    "SPR_benign = df_frameshift.query('Pathogenic == False').Delta_SPR\n",
    "nu_pathogenic = df_frameshift.query('Pathogenic == True').Delta_nu\n",
    "SPR_pathogenic = df_frameshift.query('Pathogenic == True').Delta_SPR\n",
    "\n",
    "#########\n",
    "\n",
    "bin_width = .02\n",
    "bins = np.arange(-.4, .4,bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "h = np.histogram(SPR_pathogenic,bins=bins,density=True)[0]\n",
    "ax7.bar(x,h,alpha=.8,width=bin_width,color=pt_colors['grey'],\n",
    "           label='Pathogenic')\n",
    "\n",
    "ax7.hist(SPR_benign,bins,density=True,histtype='step',\n",
    "         color='k',zorder=1,label='Benign')\n",
    "\n",
    "statistic, p_greater = stats.brunnermunzel(SPR_pathogenic, SPR_benign, alternative='greater')\n",
    "dof = f'\\nDoF: {calc_dof(SPR_pathogenic, SPR_benign):,.0f}'\n",
    "cohensd, cohensd_se = bootstrapped_cohens_d(SPR_pathogenic, SPR_benign, 100000)\n",
    "cohensd_label = f\"\\nCohen's $d$:\\n{cohensd:.2f}±{cohensd_se:.2f}\"\n",
    "p_greater_label = f'$P={format_scientific(p_greater)}$' if p_greater >= 1e-10 else '$P<1\\\\times10^{-10}$'\n",
    "leg = ax7.legend(handlelength=1,frameon=False,markerfirst=False,alignment='right',borderpad=0,loc='upper right',\n",
    "           title='Frameshift Variants'+cohensd_label+dof+'\\n'+p_greater_label)\n",
    "leg.get_title().set_ha('right') \n",
    "ax7.set_xlim(-.37,.48)\n",
    "\n",
    "#########\n",
    "\n",
    "bin_width = .005\n",
    "bins = np.arange(-.15, .15, bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "h = np.histogram(nu_pathogenic,bins=bins,density=True)[0]\n",
    "ax8.bar(x,h,alpha=.8,width=bin_width,color=pt_colors['grey'],\n",
    "           label='Pathogenic')\n",
    "\n",
    "ax8.hist(nu_benign,bins,density=True,histtype='step',\n",
    "         color='k',zorder=1,label='Benign')\n",
    "\n",
    "statistic, p_greater = stats.brunnermunzel(nu_pathogenic, nu_benign, alternative='greater')\n",
    "dof = f'\\nDoF: {calc_dof(nu_pathogenic, nu_benign):,.0f}'\n",
    "cohensd, cohensd_se = bootstrapped_cohens_d(nu_pathogenic, nu_benign, 100000)\n",
    "cohensd_label = f\"\\nCohen's $d$:\\n{cohensd:.2f}±{cohensd_se:.2f}\"\n",
    "p_greater_label = f'$P={format_scientific(p_greater)}$' if p_greater >= 1e-10 else '$P<1\\\\times10^{-10}$'\n",
    "leg = ax8.legend(handlelength=1,frameon=False,markerfirst=False,alignment='right',borderpad=0,loc='upper right',\n",
    "           title='Frameshift Variants'+cohensd_label+dof+'\\n'+p_greater_label)\n",
    "leg.get_title().set_ha('right') \n",
    "ax8.set_xlim(-.14,.15)\n",
    "\n",
    "############\n",
    "\n",
    "intervals = pd.cut(df_idrome['nu'], np.arange(.15, .8, .1))\n",
    "df_idrome['n_variants_per_res'] = df_idrome['n_variants'] / df_idrome['N'] * 100\n",
    "df = df_idrome[['nu','n_variants_per_res']]\n",
    "df.loc[:,'nu_intervals'] = intervals.values\n",
    "\n",
    "sns.stripplot(ax=ax6,data=df,x='nu_intervals',y='n_variants_per_res',\n",
    "              color='w',jitter=True,\n",
    "              size=1.5,dodge=True,edgecolor='k',linewidth=.1)\n",
    "\n",
    "mean_std = df_idrome['n_variants_per_res'].groupby(intervals).agg(['mean',se,'count'])\n",
    "mean_std['mean'].plot(rot=0, ax=ax6, kind='bar', hatch='/////',color='w',\n",
    "                      edgecolor=[pt_colors['orange']]*3+[pt_colors['cyan']]*1+[pt_colors['teal']]*2,width=1)\n",
    "mean_std['mean'].plot(rot=0, ax=ax6, kind='bar', yerr=mean_std['SE'],color='None',\n",
    "                      error_kw=dict(ecolor='black',elinewidth=0.5,capsize=2),\n",
    "                      edgecolor='None',width=1,zorder=10)\n",
    "\n",
    "ax6.set_xticks(np.arange(mean_std.index.size+1)-.5)\n",
    "ax6.set_xticklabels([.15]+[i.right for i in mean_std.index])\n",
    "\n",
    "ax6.set_ylabel('Variants per Residue %')\n",
    "ax6.set_xlabel(r'$\\nu$')\n",
    "\n",
    "ax6.set_yscale('log')\n",
    "\n",
    "############\n",
    "\n",
    "intervals = pd.cut(df_idrome['nu'], np.arange(.15, .8, .1))\n",
    "df = df_idrome[['nu','n_pubs']]\n",
    "df.loc[:,'nu_intervals'] = intervals.values\n",
    "\n",
    "sns.stripplot(ax=ax9,data=df,x='nu_intervals',y='n_pubs',\n",
    "              color='w',jitter=True,\n",
    "              size=1.5,dodge=True,edgecolor='k',linewidth=.1)\n",
    "\n",
    "mean_std = df_idrome['n_pubs'].groupby(intervals).agg(['mean',se,'count'])\n",
    "mean_std['mean'].plot(rot=0, ax=ax9, kind='bar', hatch='/////',color='w',\n",
    "                      edgecolor=[pt_colors['orange']]*3+[pt_colors['cyan']]*1+[pt_colors['teal']]*2,width=1)\n",
    "mean_std['mean'].plot(rot=0, ax=ax9, kind='bar', yerr=mean_std['SE'],color='None',\n",
    "                      error_kw=dict(ecolor='black',elinewidth=0.5,capsize=2),\n",
    "                      edgecolor='None',width=1,zorder=10)\n",
    "\n",
    "ax9.set_xticks(np.arange(mean_std.index.size+1)-.5)\n",
    "ax9.set_xticklabels([.15]+[i.right for i in mean_std.index])\n",
    "\n",
    "ax9.set_ylabel(r'Publications per IDR')\n",
    "ax9.set_xlabel(r'$\\nu$')\n",
    "\n",
    "ax9.set_yscale('log')\n",
    "\n",
    "##########\n",
    "\n",
    "ax3.set_xlim(.4,.63)\n",
    "ax1.set_xlim(9.7,10.6)\n",
    "\n",
    "ax1.set_xlabel(r'$S_\\mathrm{conf}$ / $N$ of the WT  ($k_B$)')\n",
    "ax2.set_xlabel(r'pLDDT Score of the Substituted Residue')\n",
    "ax3.set_xlabel('$\\\\nu$ of the WT')\n",
    "ax1.set_ylabel('Normalized Distribution')\n",
    "ax2.set_ylabel('Normalized Distribution')\n",
    "ax3.set_ylabel('Normalized Distribution')\n",
    "\n",
    "ax5.set_xlabel('$\\Delta \\\\nu_{\\mathrm{SVR}}$')\n",
    "ax4.set_xlabel(r'$\\Delta  S_{\\mathrm{conf},\\mathrm{SVR}}$ / $N$  ($k_B$)')\n",
    "ax5.set_ylabel('$P(\\Delta \\\\nu_{\\mathrm{SVR}})$')\n",
    "ax4.set_ylabel('$P(\\Delta  S_{\\mathrm{conf},\\mathrm{SVR}} / N)$')\n",
    "\n",
    "ax8.set_xlabel('$\\Delta \\\\nu_{\\mathrm{SVR}}$')\n",
    "ax7.set_xlabel(r'$\\Delta  S_{\\mathrm{conf},\\mathrm{SVR}}$ / $N$  ($k_B$)')\n",
    "ax8.set_ylabel('$P(\\Delta \\\\nu_{\\mathrm{SVR}})$')\n",
    "ax7.set_ylabel('$P(\\Delta  S_{\\mathrm{conf},\\mathrm{SVR}} / N)$')\n",
    "\n",
    "fig.text(0.01, .96, 'a', fontsize=10)\n",
    "fig.text(0.35, .96, 'b', fontsize=10)\n",
    "fig.text(0.67, .96, 'c', fontsize=10)\n",
    "fig.text(0.01, .64, 'd', fontsize=10)\n",
    "fig.text(0.35, .64, 'e', fontsize=10)\n",
    "fig.text(0.67, .64, 'f', fontsize=10)\n",
    "fig.text(0.01, .31, 'g', fontsize=10)\n",
    "fig.text(0.35, .31, 'h', fontsize=10)\n",
    "fig.text(0.67, .31, 'i', fontsize=10)\n",
    "\n",
    "ax2.set_ylim(0,.07)\n",
    "ax3.set_ylim(0,40)\n",
    "\n",
    "plt.tight_layout()\n",
    "fig.savefig('figs/ED_fig9.jpg',dpi=600)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea77310d",
   "metadata": {},
   "source": [
    "#### Print statistics on analysed missense variants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9b870f04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of variants 18445\n",
      "Number of pathogenic variants 2888\n",
      "Number of benign variants 15557\n",
      "Number of IDRs 6217\n",
      "Number of proteins 4292\n"
     ]
    }
   ],
   "source": [
    "print('Number of variants',df_variants.shape[0])\n",
    "print('Number of pathogenic variants',df_variants.query('significance == \"pathogenic\"').shape[0])\n",
    "print('Number of benign variants',df_variants.query('significance == \"benign\"').shape[0])\n",
    "print('Number of IDRs',df_variants.WT.unique().size)\n",
    "print('Number of proteins',df_idrome.loc[df_variants.WT].UniProt_ID.unique().size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e564455",
   "metadata": {},
   "source": [
    "#### Print statistics on analysed frameshift variants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "542b8986",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of variants 5676\n",
      "Number of pathogenic variants 637\n",
      "Number of benign variants 5039\n",
      "Number of IDRs 2273\n",
      "Number of proteins 2280\n"
     ]
    }
   ],
   "source": [
    "print('Number of variants',df_frameshift.shape[0])\n",
    "print('Number of pathogenic variants',df_frameshift.query('Pathogenic == True').shape[0])\n",
    "print('Number of benign variants',df_frameshift.query('Pathogenic == False').shape[0])\n",
    "print('Number of IDRs',df_frameshift.fasta_WT.unique().size)\n",
    "print('Number of proteins',df_frameshift.Gene.unique().size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e42a9c00",
   "metadata": {},
   "source": [
    "#### Find IDRs with low $S_{conf}/N$, $f_\\text{domain}=0$, and pathogenic variants "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e70bc165",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Homeobox protein SIX3', 'Collagen alpha-2(IV) chain',\n",
       "       'Keratin, type I cytoskeletal 16',\n",
       "       'Heterogeneous nuclear ribonucleoprotein A1',\n",
       "       'Keratin, type I cytoskeletal 10',\n",
       "       'Keratin, type II cytoskeletal 5', 'Elastin',\n",
       "       'Collagen alpha-5(IV) chain', 'Keratin, type I cytoskeletal 9',\n",
       "       'RNA-binding protein FUS', 'Collagen alpha-4(IV) chain',\n",
       "       'Collagen alpha-3(IV) chain', 'Keratin, type I cytoskeletal 12',\n",
       "       'Unconventional myosin-XV', 'Collagen alpha-1(XVII) chain'],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool_not_C = [False if ('_C' in x or x[-1]=='C') else True for x in df_variants.index]\n",
    "\n",
    "df_idrome.loc[df_variants[bool_not_C].query(\n",
    "    'significance == \"pathogenic\" and SPR_sim < 9.8 and fdomain == 0').WT,'protein_name'].unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acc5615e",
   "metadata": {},
   "source": [
    "#### Find IDRs for hnRNPA1, hnRNPA2, and FUS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6644c945",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>protein_name</th>\n",
       "      <th>nu</th>\n",
       "      <th>SPR</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>seq_name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>P09651_187_372</th>\n",
       "      <td>Heterogeneous nuclear ribonucleoprotein A1</td>\n",
       "      <td>0.453</td>\n",
       "      <td>9.626051</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>P22626_194_353</th>\n",
       "      <td>Heterogeneous nuclear ribonucleoproteins A2/B1</td>\n",
       "      <td>0.449</td>\n",
       "      <td>9.608441</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>P35637_369_526</th>\n",
       "      <td>RNA-binding protein FUS</td>\n",
       "      <td>0.497</td>\n",
       "      <td>9.788539</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>P35637_1_285</th>\n",
       "      <td>RNA-binding protein FUS</td>\n",
       "      <td>0.465</td>\n",
       "      <td>9.762312</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                  protein_name     nu  \\\n",
       "seq_name                                                                \n",
       "P09651_187_372      Heterogeneous nuclear ribonucleoprotein A1  0.453   \n",
       "P22626_194_353  Heterogeneous nuclear ribonucleoproteins A2/B1  0.449   \n",
       "P35637_369_526                         RNA-binding protein FUS  0.497   \n",
       "P35637_1_285                           RNA-binding protein FUS  0.465   \n",
       "\n",
       "                     SPR  \n",
       "seq_name                  \n",
       "P09651_187_372  9.626051  \n",
       "P22626_194_353  9.608441  \n",
       "P35637_369_526  9.788539  \n",
       "P35637_1_285    9.762312  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_idrome[df_idrome.UniProt_ID.isin(['P22626','P09651','P35637'])][['protein_name','nu','SPR']]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68008f48",
   "metadata": {},
   "source": [
    "#### Find IDRs for nucleophosmin, nuclear speckle protein snRNP subunit U1-70k, DAXX, ATRX, and CTR9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ee486143",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>protein_name</th>\n",
       "      <th>nu</th>\n",
       "      <th>SPR</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>seq_name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>P06748_122_247</th>\n",
       "      <td>Nucleophosmin</td>\n",
       "      <td>0.418</td>\n",
       "      <td>10.262282</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>P08621_202_437</th>\n",
       "      <td>U1 small nuclear ribonucleoprotein 70 kDa</td>\n",
       "      <td>0.311</td>\n",
       "      <td>9.957260</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>P46100_2419_2492</th>\n",
       "      <td>Transcriptional regulator ATRX</td>\n",
       "      <td>0.536</td>\n",
       "      <td>10.170300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>P46100_2184_2319</th>\n",
       "      <td>Transcriptional regulator ATRX</td>\n",
       "      <td>0.525</td>\n",
       "      <td>10.155034</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>P46100_1_176</th>\n",
       "      <td>Transcriptional regulator ATRX</td>\n",
       "      <td>0.520</td>\n",
       "      <td>10.104786</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>P46100_1855_2006</th>\n",
       "      <td>Transcriptional regulator ATRX</td>\n",
       "      <td>0.523</td>\n",
       "      <td>10.016912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>P46100_289_1546</th>\n",
       "      <td>Transcriptional regulator ATRX</td>\n",
       "      <td>0.482</td>\n",
       "      <td>9.962265</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q6PD62_879_1173</th>\n",
       "      <td>RNA polymerase-associated protein CTR9 homolog</td>\n",
       "      <td>0.450</td>\n",
       "      <td>9.999649</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q9UER7_1_61</th>\n",
       "      <td>Death domain-associated protein 6</td>\n",
       "      <td>0.508</td>\n",
       "      <td>10.156153</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q9UER7_399_740</th>\n",
       "      <td>Death domain-associated protein 6</td>\n",
       "      <td>0.442</td>\n",
       "      <td>10.117444</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Q9UER7_136_183</th>\n",
       "      <td>Death domain-associated protein 6</td>\n",
       "      <td>0.552</td>\n",
       "      <td>10.233137</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                    protein_name     nu  \\\n",
       "seq_name                                                                  \n",
       "P06748_122_247                                     Nucleophosmin  0.418   \n",
       "P08621_202_437         U1 small nuclear ribonucleoprotein 70 kDa  0.311   \n",
       "P46100_2419_2492                  Transcriptional regulator ATRX  0.536   \n",
       "P46100_2184_2319                  Transcriptional regulator ATRX  0.525   \n",
       "P46100_1_176                      Transcriptional regulator ATRX  0.520   \n",
       "P46100_1855_2006                  Transcriptional regulator ATRX  0.523   \n",
       "P46100_289_1546                   Transcriptional regulator ATRX  0.482   \n",
       "Q6PD62_879_1173   RNA polymerase-associated protein CTR9 homolog  0.450   \n",
       "Q9UER7_1_61                    Death domain-associated protein 6  0.508   \n",
       "Q9UER7_399_740                 Death domain-associated protein 6  0.442   \n",
       "Q9UER7_136_183                 Death domain-associated protein 6  0.552   \n",
       "\n",
       "                        SPR  \n",
       "seq_name                     \n",
       "P06748_122_247    10.262282  \n",
       "P08621_202_437     9.957260  \n",
       "P46100_2419_2492  10.170300  \n",
       "P46100_2184_2319  10.155034  \n",
       "P46100_1_176      10.104786  \n",
       "P46100_1855_2006  10.016912  \n",
       "P46100_289_1546    9.962265  \n",
       "Q6PD62_879_1173    9.999649  \n",
       "Q9UER7_1_61       10.156153  \n",
       "Q9UER7_399_740    10.117444  \n",
       "Q9UER7_136_183    10.233137  "
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_idrome[df_idrome.UniProt_ID.isin(['P06748','P08621','Q9UER7','P46100','Q6PD62'])][['protein_name','nu','SPR']]"
   ]
  }
 ],
 "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
}