go_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "61546d99",
   "metadata": {},
   "source": [
    "## Gene Ontology Analysis\n",
    "\n",
    "This notebook reproduces Fig. 2\n",
    "\n",
    "Authors: Anna Ida Trolle and Giulio Tesei\n",
    "\n",
    "Contact: giulio.tesei@bio.ku.dk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "85ae067d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import pandas as pd\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "import pickle\n",
    "from matplotlib.patches import Patch\n",
    "from scipy import stats\n",
    "from ast import literal_eval\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "import networkx as nx\n",
    "import obonet\n",
    "import time\n",
    "from matplotlib.offsetbox import AnchoredOffsetbox, TextArea, HPacker, VPacker\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",
    "from statsmodels.stats.nonparametric import rank_compare_2indep\n",
    "    \n",
    "def map_to_curated_codes(graph, GO_terms, curated_GO_codes, nodes):\n",
    "    new_codes = np.empty(0)\n",
    "    for code in GO_terms:\n",
    "        if code in nodes and code != 'unknown':\n",
    "            ancestors = list(nx.dfs_predecessors(graph, source=code, depth_limit=None).values())\n",
    "            ancestors += list(nx.dfs_predecessors(graph, source=code, depth_limit=None).keys())\n",
    "            intersect = np.intersect1d(ancestors, curated_GO_codes)\n",
    "            if intersect.size==0:\n",
    "                intersect = np.append(intersect, 'other')\n",
    "            new_codes = np.append(new_codes, intersect)\n",
    "    return np.unique(new_codes).tolist()\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 bootstrap(a,b,n_bootstrap,subsample=False):\n",
    "    cohens_d = (a.mean()-b.mean()) / np.sqrt(0.5*(a.std()**2+b.std()**2))\n",
    "    a_picked_size = a.size\n",
    "    b_picked_size = a_picked_size if subsample else b.size\n",
    "    cohen_d_b = np.empty(0)\n",
    "    W_BM_b = np.empty(0)\n",
    "    for _ in range(n_bootstrap):\n",
    "        a_p = np.random.choice(a,size=a_picked_size)\n",
    "        b_p = np.random.choice(b,size=b_picked_size)\n",
    "        cohen_d_b = np.append(cohen_d_b, (a_p.mean()-b_p.mean()) / np.sqrt(0.5*(a_p.std()**2+b_p.std()**2)))\n",
    "        W_BM_b = np.append(W_BM_b, stats.brunnermunzel(a_p, b_p)[0])\n",
    "    if cohens_d > 0:\n",
    "        pvalue_b = np.sum(W_BM_b>=0) / n_bootstrap\n",
    "    else:\n",
    "        pvalue_b = np.sum(W_BM_b<=0) / n_bootstrap\n",
    "    return cohens_d, np.std(cohen_d_b), pvalue_b\n",
    "\n",
    "def populate_table(df,a,b,prop,pvalue,name,n_bootstrap,subsample=False):\n",
    "    sub = '_sub'\n",
    "    if not subsample:\n",
    "        sub = ''\n",
    "        df.loc[name,prop+'_p'] = pvalue\n",
    "        if df.loc[name,prop+'_p'] < 1e-5:\n",
    "            df.loc[name,prop+'_p_excel'] = f'<{1e-5:.1g}'\n",
    "        else:\n",
    "            df.loc[name,prop+'_p_excel'] = f'{pvalue:.1g}'\n",
    "    cohens_d, cohens_d_se, pvalue_b = bootstrap(a,b,n_bootstrap,subsample)\n",
    "    df.loc[name,prop+'_cd'+sub] = cohens_d\n",
    "    df.loc[name,prop+'_cd_se'+sub] = cohens_d_se\n",
    "    df.loc[name,prop+'_p'] = pvalue\n",
    "    df.loc[name,prop+'_p_b'+sub] = pvalue_b\n",
    "    df.loc[name,prop+'_cd_excel'+sub] = f'{cohens_d:.2f}±{cohens_d_se:.2f}'\n",
    "    if df.loc[name,prop+'_p_b'+sub] < 1/n_bootstrap:\n",
    "        df.loc[name,prop+'_p_b_excel'+sub] = f'<{1/n_bootstrap:.1g}'\n",
    "    else:\n",
    "        df.loc[name,prop+'_p_b_excel'+sub] = f'{pvalue_b:.1g}'\n",
    "    \n",
    "def generate_stats_csv(df_idrome,prop_nu,prop_SPR,GO_dict,nodes_cat,label):\n",
    "    # Copy dict of GO terms for each UniProt ID (see go_analysis/uniprot_API_calls.py)\n",
    "    GO_terms = GO_dict.copy() \n",
    "    # Copy database\n",
    "    df_GO = df_idrome.copy()\n",
    "        \n",
    "    g,u = np.unique(GO_dict.loc[df_idrome.UniProt_ID].GO.sum(),return_counts=True)\n",
    "    curated_GO_codes = g[u>=200]\n",
    "    curated_GO_codes = np.unique(np.intersect1d(curated_GO_codes,nodes_cat))\n",
    "    curated_GO_terms = [id_to_name[x] for x in curated_GO_codes]\n",
    "    GO_terms.GO = GO_terms.GO.apply( lambda x : map_to_curated_codes(graph, x, curated_GO_codes, nodes_cat) )\n",
    "\n",
    "    df_GO['UniProt_ID'] = df_GO.UniProt_ID.apply(lambda x: [x])\n",
    "    df_GO['count_GO_terms'] = df_GO.UniProt_ID.apply(lambda x : len(GO_terms.loc[x].GO.values[0]))\n",
    "    df_GO = df_GO[df_GO['count_GO_terms']>0]\n",
    "    df_GO['GO_terms'] = df_GO.UniProt_ID.apply(\n",
    "        lambda x : [id_to_name[c] if c!='other' else 'other' for c in GO_terms.loc[x].GO.values[0]])\n",
    "    df_GO.drop('count_GO_terms',axis=1,inplace=True)\n",
    "    \n",
    "    print(df_GO.shape[0])\n",
    "    \n",
    "    statistics = pd.DataFrame(index=curated_GO_terms)\n",
    "    n_bootstrap = 100000\n",
    "    for name in curated_GO_terms:\n",
    "        bool_term = df_GO.GO_terms.apply(lambda x : name in x).values\n",
    "        p_nu = stats.brunnermunzel(df_GO[bool_term][prop_nu], \n",
    "                        df_GO[~bool_term][prop_nu], alternative='two-sided')[1]/2   \n",
    "        p_SPR = stats.brunnermunzel(df_GO[bool_term][prop_SPR], \n",
    "                        df_GO[~bool_term][prop_SPR], alternative='two-sided')[1]/2\n",
    "        if p_nu<=1e-5 or p_SPR<=1e-5:\n",
    "            print(name)\n",
    "            t0 = time.time()\n",
    "            for prop,pvalue in zip([prop_nu,prop_SPR],[p_nu,p_SPR]):\n",
    "                populate_table(statistics,df_GO[bool_term][prop].values, \n",
    "                        df_GO[~bool_term][prop].values,prop,pvalue,name,n_bootstrap,subsample=False)\n",
    "                populate_table(statistics,df_GO[bool_term][prop].values, \n",
    "                        df_GO[~bool_term][prop].values,prop,pvalue,name,n_bootstrap,subsample=True)\n",
    "            print('{:.3f} s'.format(time.time()-t0))\n",
    "            \n",
    "    statistics = statistics.sort_values(by=prop_nu+'_p')\n",
    "    statistics.to_csv(f'go_analysis/GO_stats_{label:s}.csv')\n",
    "    return df_GO\n",
    "\n",
    "def format_scientific(x):\n",
    "    a = x.split('e')[0]\n",
    "    b = int(x.split('e')[1])\n",
    "    return a+'\\\\times'+'10^{'+f'{b:d}'+'}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a8c3e983",
   "metadata": {},
   "outputs": [],
   "source": [
    "# load IDRome database\n",
    "df_idrome = pd.read_csv('IDRome_DB.csv',index_col=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83fe7e33",
   "metadata": {},
   "source": [
    "#### Load basic version of the GO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "47cc03de",
   "metadata": {},
   "outputs": [],
   "source": [
    "url = 'http://purl.obolibrary.org/obo/go/go-basic.obo'\n",
    "graph = obonet.read_obo(url)\n",
    "\n",
    "id_to_name = {id_: data.get('name') for id_, data in graph.nodes(data=True)}\n",
    "name_to_id = {data['name']: id_ for id_, data in graph.nodes(data=True) if 'name' in data}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cd822c2",
   "metadata": {},
   "source": [
    "#### Get nodes connected to molecular function, biological process, and cellular component"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f650e991",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GO:0003674 GO:0008150 GO:0005575\n"
     ]
    }
   ],
   "source": [
    "print(name_to_id['molecular_function'],name_to_id['biological_process'],name_to_id['cellular_component'])\n",
    "molfunc = list(nx.ancestors(graph, 'GO:0003674')) # all nodes connected to molecular function\n",
    "bioproc = list(nx.ancestors(graph, 'GO:0008150')) # all nodes connected to biological process\n",
    "cellcom = list(nx.ancestors(graph, 'GO:0005575')) # all nodes connected to cellular component"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dc7f541",
   "metadata": {},
   "source": [
    "# Brunner Munzel Test on $\\nu$ and $S_\\text{conf}$ Distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a87b7193",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_idrome = pd.read_csv('IDRome_DB.csv',index_col=0)\n",
    "GO_dict = pd.Series(pd.read_pickle('go_analysis/uniprot_dict.pkl')).to_frame(name='GO')\n",
    "df_GO_molfunc = generate_stats_csv(df_idrome,'nu','SPR',GO_dict,molfunc,'molfunc')\n",
    "df_GO_cellcom = generate_stats_csv(df_idrome,'nu','SPR',GO_dict,cellcom,'cellcom')\n",
    "\n",
    "df_GO_molfunc.to_pickle('go_analysis/df_GO_molfunc.pkl')\n",
    "df_GO_cellcom.to_pickle('go_analysis/df_GO_cellcom.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6759687c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_idrome = pd.read_csv('IDRome_DB.csv',index_col=0)\n",
    "df_idrome = df_idrome.query('fdomain == 0')\n",
    "GO_dict = pd.Series(pd.read_pickle('go_analysis/uniprot_dict.pkl')).to_frame(name='GO')\n",
    "_ = generate_stats_csv(df_idrome,'nu','SPR',GO_dict,molfunc,'molfunc_no_domains')\n",
    "_ = generate_stats_csv(df_idrome,'nu','SPR',GO_dict,cellcom,'cellcom_no_domains')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "114d824e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_idrome_spot = pd.read_csv('IDRome_DB_SPOT.csv',index_col=0)\n",
    "GO_dict_spot = pd.Series(pd.read_pickle('go_analysis/uniprot_dict_SPOT.pkl')).to_frame(name='GO')\n",
    "_ = generate_stats_csv(df_idrome_spot,'nu_svr','SPR_svr',GO_dict_spot,molfunc,'molfunc_spot')\n",
    "_ = generate_stats_csv(df_idrome_spot,'nu_svr','SPR_svr',GO_dict_spot,cellcom,'cellcom_spot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5847ea1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_GO_molfunc = pd.read_pickle('go_analysis/df_GO_molfunc.pkl')\n",
    "df_GO_cellcom = pd.read_pickle('go_analysis/df_GO_cellcom.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b7f8586",
   "metadata": {},
   "source": [
    "#### Excel Sheets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "75217271",
   "metadata": {},
   "outputs": [],
   "source": [
    "writer = pd.ExcelWriter('../Supplementary_Table_1.xlsx', engine='xlsxwriter')\n",
    "#################\n",
    "df_molfunc = pd.read_csv('go_analysis/GO_stats_molfunc.csv',index_col=0)\n",
    "df_molfunc.nu_p_excel = df_molfunc.nu_p.apply(lambda x: f'{x:.1g}')\n",
    "df_molfunc.SPR_p_excel = df_molfunc.SPR_p.apply(lambda x: f'{x:.1g}')\n",
    "df_molfunc_no_domains = pd.read_csv('go_analysis/GO_stats_molfunc_no_domains.csv',index_col=0)\n",
    "df_molfunc_no_domains.nu_p_excel = df_molfunc_no_domains.nu_p.apply(lambda x: f'{x:.1g}')\n",
    "df_molfunc_no_domains.SPR_p_excel = df_molfunc_no_domains.SPR_p.apply(lambda x: f'{x:.1g}')\n",
    "df_molfunc_spot = pd.read_csv('go_analysis/GO_stats_molfunc_spot.csv',index_col=0)\n",
    "df_molfunc_spot.nu_svr_p_excel = df_molfunc_spot.nu_svr_p.apply(lambda x: f'{x:.1g}')\n",
    "df_molfunc_spot.SPR_svr_p_excel = df_molfunc_spot.SPR_svr_p.apply(lambda x: f'{x:.1g}')\n",
    "df_molfunc_all = df_molfunc[['nu_p','nu_p_excel','SPR_p_excel']].join(\n",
    "                 df_molfunc_no_domains[['nu_p','nu_p_excel','SPR_p_excel']], \n",
    "                 lsuffix='_pLDDT', rsuffix='_nodomain', how='outer')\n",
    "df_molfunc_spot.columns = df_molfunc_spot.columns.map(lambda x: str(x) + '_SPOT')\n",
    "df_molfunc_all = df_molfunc_all.join(\n",
    "                 df_molfunc_spot[['nu_svr_p_SPOT','nu_svr_p_excel_SPOT','SPR_svr_p_excel_SPOT']],how='outer')\n",
    "df_molfunc_all = df_molfunc_all.sort_values('nu_p_pLDDT')\n",
    "df_molfunc_all = df_molfunc_all.dropna()\n",
    "df_molfunc_all.drop(['nu_p_pLDDT','nu_p_nodomain','nu_svr_p_SPOT'],axis=1,inplace=True)\n",
    "df_molfunc_all.to_excel(writer, \n",
    "    sheet_name='molecular functions, p-values')\n",
    "#################\n",
    "df_molfunc = pd.read_csv('go_analysis/GO_stats_molfunc.csv',index_col=0)\n",
    "df_molfunc_no_domains = pd.read_csv('go_analysis/GO_stats_molfunc_no_domains.csv',index_col=0)\n",
    "df_molfunc_spot = pd.read_csv('go_analysis/GO_stats_molfunc_spot.csv',index_col=0)\n",
    "df_molfunc_all = df_molfunc[['nu_p','nu_cd_excel','SPR_cd_excel']].join(\n",
    "                 df_molfunc_no_domains[['nu_cd_excel','SPR_cd_excel']], \n",
    "                 lsuffix='_pLDDT', rsuffix='_nodomain', how='outer')\n",
    "df_molfunc_spot.columns = df_molfunc_spot.columns.map(lambda x: str(x) + '_SPOT')\n",
    "df_molfunc_all = df_molfunc_all.join(\n",
    "                 df_molfunc_spot[['nu_svr_cd_excel_SPOT','SPR_svr_cd_excel_SPOT']],how='outer')\n",
    "df_molfunc_all = df_molfunc_all.sort_values('nu_p')\n",
    "df_molfunc_all = df_molfunc_all.dropna()\n",
    "df_molfunc_all.drop('nu_p',axis=1,inplace=True)\n",
    "df_molfunc_all.to_excel(writer, \n",
    "    sheet_name=\"cohen's d\")\n",
    "#################\n",
    "df_molfunc = pd.read_csv('go_analysis/GO_stats_molfunc.csv',index_col=0)\n",
    "df_molfunc_no_domains = pd.read_csv('go_analysis/GO_stats_molfunc_no_domains.csv',index_col=0)\n",
    "df_molfunc_spot = pd.read_csv('go_analysis/GO_stats_molfunc_spot.csv',index_col=0)\n",
    "df_molfunc_all = df_molfunc[['nu_p','nu_p_b_excel','SPR_p_b_excel']].join(\n",
    "                 df_molfunc_no_domains[['nu_p_b_excel','SPR_p_b_excel']], \n",
    "                 lsuffix='_pLDDT', rsuffix='_nodomain', how='outer')\n",
    "df_molfunc_spot.columns = df_molfunc_spot.columns.map(lambda x: str(x) + '_SPOT')\n",
    "df_molfunc_all = df_molfunc_all.join(\n",
    "                 df_molfunc_spot[['nu_svr_p_b_excel_SPOT','SPR_svr_p_b_excel_SPOT']],how='outer')\n",
    "df_molfunc_all = df_molfunc_all.sort_values('nu_p')\n",
    "df_molfunc_all = df_molfunc_all.dropna()\n",
    "df_molfunc_all.drop('nu_p',axis=1,inplace=True)\n",
    "df_molfunc_all.to_excel(writer, \n",
    "    sheet_name='p-values (bootstrap)')\n",
    "#################\n",
    "df_molfunc = pd.read_csv('go_analysis/GO_stats_molfunc.csv',index_col=0)\n",
    "df_molfunc_no_domains = pd.read_csv('go_analysis/GO_stats_molfunc_no_domains.csv',index_col=0)\n",
    "df_molfunc_spot = pd.read_csv('go_analysis/GO_stats_molfunc_spot.csv',index_col=0)\n",
    "df_molfunc_all = df_molfunc[['nu_p','nu_p_b_excel_sub','SPR_p_b_excel_sub']].join(\n",
    "                 df_molfunc_no_domains[['nu_p_b_excel_sub','SPR_p_b_excel_sub']], \n",
    "                 lsuffix='_pLDDT', rsuffix='_nodomain', how='outer')\n",
    "df_molfunc_spot.columns = df_molfunc_spot.columns.map(lambda x: str(x) + '_SPOT')\n",
    "df_molfunc_all = df_molfunc_all.join(\n",
    "                 df_molfunc_spot[['nu_svr_p_b_excel_sub_SPOT','SPR_svr_p_b_excel_sub_SPOT']],how='outer')\n",
    "df_molfunc_all = df_molfunc_all.sort_values('nu_p')\n",
    "df_molfunc_all = df_molfunc_all.dropna()\n",
    "df_molfunc_all.drop('nu_p',axis=1,inplace=True)\n",
    "df_molfunc_all.to_excel(writer, \n",
    "    sheet_name='p-values (subsampling)')\n",
    "writer.save()\n",
    "#################\n",
    "writer = pd.ExcelWriter('../Supplementary_Table_2.xlsx', engine='xlsxwriter')\n",
    "#################\n",
    "df_cellcom = pd.read_csv('go_analysis/GO_stats_cellcom.csv',index_col=0)\n",
    "df_cellcom.nu_p_excel = df_cellcom.nu_p.apply(lambda x: f'{x:.1g}')\n",
    "df_cellcom.SPR_p_excel = df_cellcom.SPR_p.apply(lambda x: f'{x:.1g}')\n",
    "df_cellcom_no_domains = pd.read_csv('go_analysis/GO_stats_cellcom_no_domains.csv',index_col=0)\n",
    "df_cellcom_no_domains.nu_p_excel = df_cellcom_no_domains.nu_p.apply(lambda x: f'{x:.1g}')\n",
    "df_cellcom_no_domains.SPR_p_excel = df_cellcom_no_domains.SPR_p.apply(lambda x: f'{x:.1g}')\n",
    "df_cellcom_spot = pd.read_csv('go_analysis/GO_stats_cellcom_spot.csv',index_col=0)\n",
    "df_cellcom_spot.nu_svr_p_excel = df_cellcom_spot.nu_svr_p.apply(lambda x: f'{x:.1g}')\n",
    "df_cellcom_spot.SPR_svr_p_excel = df_cellcom_spot.SPR_svr_p.apply(lambda x: f'{x:.1g}')\n",
    "df_cellcom_all = df_cellcom[['nu_p','nu_p_excel','SPR_p_excel']].join(\n",
    "                 df_cellcom_no_domains[['nu_p','nu_p_excel','SPR_p_excel']], \n",
    "                 lsuffix='_pLDDT', rsuffix='_nodomain', how='outer')\n",
    "df_cellcom_spot.columns = df_cellcom_spot.columns.map(lambda x: str(x) + '_SPOT')\n",
    "df_cellcom_all = df_cellcom_all.join(\n",
    "                 df_cellcom_spot[['nu_svr_p_SPOT','nu_svr_p_excel_SPOT','SPR_svr_p_excel_SPOT']],how='outer')\n",
    "df_cellcom_all = df_cellcom_all.sort_values('nu_p_pLDDT')\n",
    "df_cellcom_all = df_cellcom_all.dropna()\n",
    "df_cellcom_all.drop(['nu_p_pLDDT','nu_p_nodomain','nu_svr_p_SPOT'],axis=1,inplace=True)\n",
    "df_cellcom_all.to_excel(writer, \n",
    "    sheet_name='cell compartments, p-values')\n",
    "#################\n",
    "df_cellcom = pd.read_csv('go_analysis/GO_stats_cellcom.csv',index_col=0)\n",
    "df_cellcom_no_domains = pd.read_csv('go_analysis/GO_stats_cellcom_no_domains.csv',index_col=0)\n",
    "df_cellcom_spot = pd.read_csv('go_analysis/GO_stats_cellcom_spot.csv',index_col=0)\n",
    "df_cellcom_all = df_cellcom[['nu_p','nu_cd_excel','SPR_cd_excel']].join(\n",
    "                 df_cellcom_no_domains[['nu_cd_excel','SPR_cd_excel']], \n",
    "                 lsuffix='_pLDDT', rsuffix='_nodomain', how='outer')\n",
    "df_cellcom_spot.columns = df_cellcom_spot.columns.map(lambda x: str(x) + '_SPOT')\n",
    "df_cellcom_all = df_cellcom_all.join(\n",
    "                 df_cellcom_spot[['nu_svr_cd_excel_SPOT','SPR_svr_cd_excel_SPOT']],how='outer')\n",
    "df_cellcom_all = df_cellcom_all.sort_values('nu_p')\n",
    "df_cellcom_all = df_cellcom_all.dropna()\n",
    "df_cellcom_all.drop('nu_p',axis=1,inplace=True)\n",
    "df_cellcom_all.to_excel(writer, \n",
    "    sheet_name=\"cell compartments, cohen's d\")\n",
    "#################\n",
    "df_cellcom = pd.read_csv('go_analysis/GO_stats_cellcom.csv',index_col=0)\n",
    "df_cellcom_no_domains = pd.read_csv('go_analysis/GO_stats_cellcom_no_domains.csv',index_col=0)\n",
    "df_cellcom_spot = pd.read_csv('go_analysis/GO_stats_cellcom_spot.csv',index_col=0)\n",
    "df_cellcom_all = df_cellcom[['nu_p','nu_p_b_excel','SPR_p_b_excel']].join(\n",
    "                 df_cellcom_no_domains[['nu_p_b_excel','SPR_p_b_excel']], \n",
    "                 lsuffix='_pLDDT', rsuffix='_nodomain', how='outer')\n",
    "df_cellcom_spot.columns = df_cellcom_spot.columns.map(lambda x: str(x) + '_SPOT')\n",
    "df_cellcom_all = df_cellcom_all.join(\n",
    "                 df_cellcom_spot[['nu_svr_p_b_excel_SPOT','SPR_svr_p_b_excel_SPOT']],how='outer')\n",
    "df_cellcom_all = df_cellcom_all.sort_values('nu_p')\n",
    "df_cellcom_all = df_cellcom_all.dropna()\n",
    "df_cellcom_all.drop('nu_p',axis=1,inplace=True)\n",
    "df_cellcom_all.to_excel(writer, \n",
    "    sheet_name='p-values (bootstrap)')\n",
    "#################\n",
    "df_cellcom = pd.read_csv('go_analysis/GO_stats_cellcom.csv',index_col=0)\n",
    "df_cellcom_no_domains = pd.read_csv('go_analysis/GO_stats_cellcom_no_domains.csv',index_col=0)\n",
    "df_cellcom_spot = pd.read_csv('go_analysis/GO_stats_cellcom_spot.csv',index_col=0)\n",
    "df_cellcom_all = df_cellcom[['nu_p','nu_p_b_excel_sub','SPR_p_b_excel_sub']].join(\n",
    "                 df_cellcom_no_domains[['nu_p_b_excel_sub','SPR_p_b_excel_sub']], \n",
    "                 lsuffix='_pLDDT', rsuffix='_nodomain', how='outer')\n",
    "df_cellcom_spot.columns = df_cellcom_spot.columns.map(lambda x: str(x) + '_SPOT')\n",
    "df_cellcom_all = df_cellcom_all.join(\n",
    "                 df_cellcom_spot[['nu_svr_p_b_excel_sub_SPOT','SPR_svr_p_b_excel_sub_SPOT']],how='outer')\n",
    "df_cellcom_all = df_cellcom_all.sort_values('nu_p')\n",
    "df_cellcom_all = df_cellcom_all.dropna()\n",
    "df_cellcom_all.drop('nu_p',axis=1,inplace=True)\n",
    "df_cellcom_all.to_excel(writer, \n",
    "    sheet_name='p-values (subsampling)')\n",
    "writer.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a973a4d2",
   "metadata": {},
   "source": [
    "#### Fig. 2a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5fc930c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transcription cis-regulatory region binding: -0.22±0.02 vs -0.22\n",
      "G protein-coupled receptor activity: 0.15±0.03 vs 0.14\n",
      "chromatin binding: -0.16±0.03 vs -0.18\n",
      "GTP binding: 0.22±0.07 vs 0.23\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x380 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f, axes = plt.subplots(3, 2, sharex=False, sharey=False, figsize=(3,3.8))\n",
    "plt.rc('font', **{'family':'sans-serif','sans-serif':['Arial'], 'size': 6})\n",
    "\n",
    "df_molfunc = pd.read_csv('go_analysis/GO_stats_molfunc.csv',index_col=0)\n",
    "df_molfunc.nu_p_excel = df_molfunc.nu_p.apply(lambda x: f'<{1e-10:.1g}' if x<1e-10 else f'{x:.1g}')\n",
    "df_molfunc.SPR_p_excel = df_molfunc.SPR_p.apply(lambda x: f'<{1e-10:.1g}' if x<1e-10 else f'{x:.1g}')\n",
    "\n",
    "bin_width = .006\n",
    "bins = np.arange(0.25, .74,bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "for name,ax in zip(['transcription cis-regulatory region binding','G protein-coupled receptor activity',\n",
    "                    'chromatin binding','GTP binding'],axes.flatten()):\n",
    "    bool_term = df_GO_molfunc.GO_terms.apply(lambda x : name in x).values\n",
    "    \n",
    "    a = df_GO_molfunc[bool_term].nu\n",
    "    b = df_GO_molfunc[~bool_term].nu\n",
    "    \n",
    "    N_IDRs = df_GO_molfunc[bool_term].shape[0]\n",
    "        \n",
    "    h = np.histogram(a,bins=bins,density=True)[0]\n",
    "        \n",
    "    ax.hist(b,bins,density=True,histtype='step',color='k',zorder=0)\n",
    "    \n",
    "    alternative = 'greater'\n",
    "    color = pt_colors['teal']\n",
    "    if a.mean() < b.mean():\n",
    "        alternative = 'less'\n",
    "        color = pt_colors['orange']\n",
    "    t,p = stats.ttest_ind(a, b, \n",
    "                          equal_var=False, alternative=alternative)\n",
    "\n",
    "    cohens_d_str = df_molfunc.loc[name,'nu_cd_excel']\n",
    "    pvalue_str = df_molfunc.loc[name,'nu_p_excel']\n",
    "    pvalue_str = '='+format_scientific(pvalue_str) if pvalue_str != '<1e-10' else '<10^{-10}'\n",
    "        \n",
    "    print(name+':',cohens_d_str, 'vs', round( \n",
    "        (np.mean(a)-np.mean(b)) / np.std(np.append(a-np.mean(a),b-np.mean(b))) ,2) )\n",
    "    dof = f'\\nDoF: {calc_dof(a,b):,.0f}'\n",
    "    \n",
    "    ax.bar(x,h,alpha=.7,width=bin_width,color=color,\n",
    "          label=f'{N_IDRs:,d} IDRs'+dof+\"\\nCohen's $d$:\\n\"+cohens_d_str+f'\\n$P{pvalue_str}$')\n",
    "    \n",
    "    if name == 'transcription cis-regulatory region binding':\n",
    "        ax.set_title('Transcription cis-regulatory\\nregion binding')\n",
    "    elif name == 'GTP binding':\n",
    "        ax.set_title('GTP binding')\n",
    "    elif name == 'chromatin binding':\n",
    "        ax.set_title('Chromatin binding')\n",
    "    elif name == 'G protein-coupled receptor activity':\n",
    "        ax.set_title('G protein-coupled\\nreceptor activity')\n",
    "    else:\n",
    "        ax.set_title(name.capitalize())\n",
    "    ax.set_xlim(.37,.66)\n",
    "    legend = ax.legend(handlelength=0,frameon=False,borderpad=0,loc=(-.03,.24))\n",
    "    legend.get_title().set_ha('center')  \n",
    "    \n",
    "bin_width = .03\n",
    "bins = np.arange(9.3, 11.5,bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "for name,ax in zip(['ATP binding',\n",
    "                    'signaling receptor activity'],axes.flatten()[-2:]):\n",
    "    \n",
    "    bool_term = df_GO_molfunc.GO_terms.apply(lambda x : name in x).values\n",
    "    \n",
    "    a = df_GO_molfunc[bool_term].SPR\n",
    "    b = df_GO_molfunc[~bool_term].SPR\n",
    "    \n",
    "    N_IDRs = df_GO_molfunc[bool_term].shape[0]\n",
    "    \n",
    "    h = np.histogram(a,bins=bins,density=True)[0]\n",
    "        \n",
    "    ax.hist(b,bins,density=True,histtype='step',color='k',zorder=0)\n",
    "    \n",
    "    alternative = 'greater'\n",
    "    color = pt_colors['teal']\n",
    "    if a.mean() < b.mean():\n",
    "        alternative = 'less'\n",
    "        color = pt_colors['orange']\n",
    "    t,p = stats.ttest_ind(a, b, \n",
    "                          equal_var=False, alternative=alternative)\n",
    "    \n",
    "    cohens_d_str = df_molfunc.loc[name,'SPR_cd_excel']\n",
    "    pvalue_str = df_molfunc.loc[name,'SPR_p_excel']\n",
    "    pvalue_str = '='+format_scientific(pvalue_str) if pvalue_str != '<1e-10' else '<10^{-10}'\n",
    "        \n",
    "    dof = f'\\nDoF: {calc_dof(a,b):,.0f}'\n",
    "    \n",
    "    ax.bar(x,h,alpha=.7,width=bin_width,color=color,\n",
    "          label=f'{N_IDRs:,d} IDRs'+dof+\"\\nCohen's $d$:\\n\"+cohens_d_str+f'\\n$P{pvalue_str}$')\n",
    "    \n",
    "    if name == 'ATP binding':\n",
    "        ax.set_title('ATP binding')\n",
    "    else:\n",
    "        ax.set_title(name.capitalize())\n",
    "    ax.set_xlim(9.5,10.6)\n",
    "    legend = ax.legend(handlelength=0,frameon=False,borderpad=0,loc=(-.03,.24))\n",
    "    legend.get_title().set_ha('center')    \n",
    "    \n",
    "for ax in axes[:2,:].flatten():\n",
    "    ax.set_xlabel('$\\\\nu$')\n",
    "for ax in axes[:2,0]:\n",
    "    ax.set_ylabel('$P(\\\\nu)$')\n",
    "for ax in axes[-1,:]:\n",
    "    ax.set_xlabel('$S_\\mathrm{conf}/N$  ($k_B$)')\n",
    "for ax in axes[-1:,0]:\n",
    "    ax.set_ylabel('$P(S_\\mathrm{conf}/N)$')    \n",
    "    \n",
    "plt.tight_layout(h_pad=0)\n",
    "plt.savefig('figs/fig2a.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c0d6693",
   "metadata": {},
   "source": [
    "#### Fig. 2b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0de12f89",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 380x380 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f, axes = plt.subplots(3, 3, sharex=True, sharey=False, figsize=(3.8,3.8))\n",
    "plt.rc('font', **{'family':'sans-serif','sans-serif':['Arial'], 'size': 6})\n",
    "\n",
    "df_cellcom = pd.read_csv('go_analysis/GO_stats_cellcom.csv',index_col=0)\n",
    "df_cellcom.nu_p_excel = df_cellcom.nu_p.apply(lambda x: f'<{1e-10:.1g}' if x<1e-10 else f'{x:.1g}')\n",
    "df_cellcom.SPR_p_excel = df_cellcom.SPR_p.apply(lambda x: f'<{1e-10:.1g}' if x<1e-10 else f'{x:.1g}')\n",
    "\n",
    "bin_width = .006\n",
    "bins = np.arange(0.25, .74,bin_width)\n",
    "x = bins[:-1]+bin_width/2.\n",
    "\n",
    "for name,i in zip(['nuclear body','nuclear speck','mitochondrial matrix','endosome','chromatin'],[2,5,6,7,8]):\n",
    "    ax = axes.flatten()[i]\n",
    "    bool_term = df_GO_cellcom.GO_terms.apply(lambda x : name in x).values\n",
    "    \n",
    "    a = df_GO_cellcom[bool_term].nu\n",
    "    b = df_GO_cellcom[~bool_term].nu\n",
    "    \n",
    "    h_1 = np.histogram(a,bins=bins,density=True)[0]\n",
    "    h_2 = np.histogram(b,bins=bins,density=True)[0]\n",
    "    \n",
    "    N_IDRs = df_GO_cellcom[bool_term].shape[0]\n",
    "    \n",
    "    ax.hist(b,bins,density=True,histtype='step',color='k',zorder=0)\n",
    "    \n",
    "    alternative = 'greater'\n",
    "    color = pt_colors['teal']\n",
    "    if a.mean() < b.mean():\n",
    "        alternative = 'less'\n",
    "        color = pt_colors['orange']\n",
    "    t,p = stats.ttest_ind(a, b, \n",
    "                          equal_var=False, alternative=alternative)\n",
    "\n",
    "    cohens_d_str = df_cellcom.loc[name,'nu_cd_excel']\n",
    "    pvalue_str = df_cellcom.loc[name,'nu_p_excel']\n",
    "    pvalue_str = '='+format_scientific(pvalue_str) if pvalue_str != '<1e-10' else '<1\\\\times10^{-10}'\n",
    "    \n",
    "    dof = f'\\nDoF: {calc_dof(a,b):,.0f}'\n",
    "    \n",
    "    ax.bar(x,h_1,alpha=.7,width=bin_width,color=color,\n",
    "          label=f'{N_IDRs:,d} IDRs'+dof+\"\\nCohen's $d$:\\n\"+cohens_d_str+f'\\n$P{pvalue_str}$')\n",
    "    \n",
    "    if name in ['nuclear body','nuclear speck']:\n",
    "        ax.set_ylim(0,15)\n",
    "\n",
    "    if name == 'nuclear speck':\n",
    "        name = 'nuclear speckle'\n",
    "    \n",
    "    ax.set_title(name.capitalize())\n",
    "\n",
    "    ax.set_xlim(.37,.62)\n",
    "    ax.set_xticks([.4,.5,.6])\n",
    "    legend = ax.legend(handlelength=0,frameon=False,borderpad=0,loc=(-.04,.4))\n",
    "\n",
    "    ax.yaxis.tick_right()\n",
    "    ax.yaxis.set_label_position(\"right\")\n",
    "    \n",
    "for ax in axes[-1,:]:\n",
    "    ax.set_xlabel('$\\\\nu$')\n",
    "for ax in axes[:,2]:\n",
    "    ax.set_ylabel('$P(\\\\nu)$')\n",
    "for ax in axes[:2,:2].flatten():\n",
    "    ax.axis('off')\n",
    "plt.tight_layout()\n",
    "plt.savefig('figs/fig2b.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1c82398",
   "metadata": {},
   "source": [
    "#### Searching for TFs analysed by Staller et al. (DOI: https://doi.org/10.1016/j.cels.2022.01.002)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "648a8de3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Forkhead box protein O6 0.455\n",
      "Transcription factor SOX-11 0.474\n",
      "Forkhead box protein O4 0.443\n",
      "Zinc finger protein interacting with ribonucleoprotein K 0.472\n",
      "Coiled-coil and C2 domain-containing protein 1A 0.438\n",
      "Pancreas transcription factor 1 subunit alpha 0.401\n",
      "Zinc finger and BTB domain-containing protein 46 0.456\n",
      "Adipocyte enhancer-binding protein 1 0.438\n",
      "Zinc finger protein 561 0.454\n",
      "Zinc finger protein 473 0.439\n",
      "HMG box transcription factor BBX 0.413\n",
      "Zinc finger protein 419 0.464\n",
      "Zinc finger protein 42 homolog 0.468\n",
      "Homeobox protein ARX 0.41\n",
      "ETS-related transcription factor Elf-4 0.448\n",
      "Zinc finger protein 644 0.438\n",
      "PR domain zinc finger protein 5 0.457\n",
      "CXXC-type zinc finger protein 1 0.456\n",
      "Zinc finger protein 639 0.465\n",
      "Zinc finger protein 777 0.412\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "dataset_3 = pd.read_csv('https://ars.els-cdn.com/content/image/1-s2.0-S2405471222000023-mmc4.csv',\n",
    "           storage_options={'User-Agent': 'Mozilla/5.0'},index_col=2)\n",
    "\n",
    "tfs_staller = []\n",
    "\n",
    "df_staller = df_GO_molfunc[df_GO_molfunc.UniProt_ID.apply(lambda x: x[0]).isin(dataset_3.index)]\n",
    "bool_term = df_staller.GO_terms.apply(lambda x : 'transcription cis-regulatory region binding' in x).values\n",
    "df_staller = df_staller[bool_term].query('nu <= 0.475')\n",
    "for idr in df_staller.index:\n",
    "    if type(dataset_3.loc[df_staller.loc[idr].UniProt_ID].ProteinRegionSeq) == str:\n",
    "        if dataset_3.loc[df_staller.loc[idr].UniProt_ID].ProteinRegionSeq in df_staller.loc[idr].fasta:\n",
    "            print(df_staller.loc[idr].protein_name,df_staller.loc[idr].nu)\n",
    "            tfs_staller.append(idr)\n",
    "    else:\n",
    "        for seq in dataset_3.loc[df_staller.loc[idr].UniProt_ID].ProteinRegionSeq.values:\n",
    "            if seq in df_staller.loc[idr].fasta:\n",
    "                print(df_staller.loc[idr].protein_name,df_staller.loc[idr].nu)\n",
    "                tfs_staller.append(idr)\n",
    "print(np.unique(tfs_staller).size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "18dd3d4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "107\n"
     ]
    }
   ],
   "source": [
    "dataset_3 = pd.read_csv('https://ars.els-cdn.com/content/image/1-s2.0-S2405471222000023-mmc4.csv',\n",
    "           storage_options={'User-Agent': 'Mozilla/5.0'},index_col=2)\n",
    "\n",
    "tfs_staller = []\n",
    "\n",
    "df_staller = df_GO_molfunc[df_GO_molfunc.UniProt_ID.apply(lambda x: x[0]).isin(dataset_3.index)]\n",
    "for idr in df_staller.index:\n",
    "    if type(dataset_3.loc[df_staller.loc[idr].UniProt_ID].ProteinRegionSeq) == str:\n",
    "        if dataset_3.loc[df_staller.loc[idr].UniProt_ID].ProteinRegionSeq in df_staller.loc[idr].fasta:\n",
    "            #print(df_staller.loc[idr].protein_name,df_staller.loc[idr].GO_terms)\n",
    "            tfs_staller.append(idr)\n",
    "    else:\n",
    "        for seq in dataset_3.loc[df_staller.loc[idr].UniProt_ID].ProteinRegionSeq.values:\n",
    "            if seq in df_staller.loc[idr].fasta:\n",
    "                #print(df_staller.loc[idr].protein_name,df_staller.loc[idr].GO_terms)\n",
    "                tfs_staller.append(idr)\n",
    "print(np.unique(tfs_staller).size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85cb1920",
   "metadata": {},
   "source": [
    "#### Proteins with compact IDRs that localize in intracellular membraneless organelles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3fbda016",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(441, 'intracellular non-membrane-bounded organelle')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GO_terms = pd.Series(pd.read_pickle('go_analysis/uniprot_dict.pkl')).to_frame(name='GO')\n",
    "go_ids_mlos = [name_to_id[name] for name in ['intracellular non-membrane-bounded organelle']]\n",
    "GO_terms.GO = GO_terms.GO.apply( lambda x : map_to_curated_codes(graph, x, go_ids_mlos, cellcom) )\n",
    "nuc_mos = GO_terms.loc[df_idrome.query('nu <= 0.475').UniProt_ID][\n",
    "    GO_terms.loc[df_idrome.query('nu <= 0.475').UniProt_ID].GO.apply(lambda x:\n",
    "    np.sum([i in go_ids_mlos for i in x])>0).values].index.unique()\n",
    "nuc_mos.size, 'intracellular non-membrane-bounded organelle'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92bf6248",
   "metadata": {},
   "source": [
    "#### Proteins with compact IDRs that localize in nucleoli, nuclear speckles, nuclear bodies, and PML bodies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9fa7b47e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(224, 'nucleolus', 'nuclear speck', 'nuclear body', 'PML body')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GO_terms = pd.Series(pd.read_pickle('go_analysis/uniprot_dict.pkl')).to_frame(name='GO')\n",
    "go_ids_nuclear_condensates = [name_to_id[name] for name in ['nucleolus','nuclear speck','nuclear body','PML body']]\n",
    "GO_terms.GO = GO_terms.GO.apply( lambda x : map_to_curated_codes(graph, x, go_ids_nuclear_condensates, cellcom) )\n",
    "nuc_mos = GO_terms.loc[df_idrome.query('nu <= 0.475').UniProt_ID][\n",
    "    GO_terms.loc[df_idrome.query('nu <= 0.475').UniProt_ID].GO.apply(lambda x:\n",
    "    np.sum([i in go_ids_nuclear_condensates for i in x])>0).values].index.unique()\n",
    "nuc_mos.size, 'nucleolus', 'nuclear speck', 'nuclear body', 'PML body'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fae481d3",
   "metadata": {},
   "source": [
    "#### Example: Find IDRs with a specific GO term"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f77e8cb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "seq_name\n",
       "A0A024RBG1_145_181    Diphosphoinositol polyphosphate phosphohydrola...\n",
       "A0A0B4J2F2_350_783       Putative serine/threonine-protein kinase SIK1B\n",
       "A0A0B4J2F2_278_307       Putative serine/threonine-protein kinase SIK1B\n",
       "A0A0U1RR11_239_272                  Centromere protein V-like protein 1\n",
       "A0A0U1RR11_1_90                     Centromere protein V-like protein 1\n",
       "                                            ...                        \n",
       "Q9Y6X9_576_795                                             ATPase MORC2\n",
       "Q9Y6Y8_1_269                                  SEC23-interacting protein\n",
       "Q9Y6Y8_595_653                                SEC23-interacting protein\n",
       "Q9Y6Y8_709_773                                SEC23-interacting protein\n",
       "Q9Y6Y8_853_947                                SEC23-interacting protein\n",
       "Name: protein_name, Length: 6724, dtype: object"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load lists of GO terms for each UniProt ID (see go_analysis/uniprot_API_calls.py)\n",
    "GO_terms = pd.Series(pd.read_pickle('go_analysis/uniprot_dict.pkl')).to_frame(name='GO')\n",
    "# Load database\n",
    "df_GO = pd.read_csv('IDRome_DB.csv',index_col=0)\n",
    "# Map GO terms that have catalytic activity as parent term\n",
    "curated_GO_codes = ['GO:0003824']\n",
    "GO_terms.GO = GO_terms.GO.apply( lambda x : map_to_curated_codes(graph, x, curated_GO_codes, molfunc) )\n",
    "\n",
    "df_GO['UniProt_ID'] = df_GO.UniProt_ID.apply(lambda x: [x])\n",
    "df_GO['count_GO_terms'] = df_GO.UniProt_ID.apply(lambda x : len(GO_terms.loc[x].GO.values[0]))\n",
    "df_GO = df_GO[df_GO['count_GO_terms']>0]\n",
    "df_GO['GO_terms'] = df_GO.UniProt_ID.apply(\n",
    "    lambda x : [id_to_name[c] if c!='other' else 'other' for c in GO_terms.loc[x].GO.values[0]])\n",
    "df_GO['GO_terms'] = df_GO.GO_terms.apply(lambda x : 0 if x==['other'] else x[0])\n",
    "df_GO.drop('count_GO_terms',axis=1,inplace=True)\n",
    "df_GO['UniProt_ID'] = df_GO.UniProt_ID.apply(lambda x: x[0])\n",
    "\n",
    "df_idrome = pd.read_csv('IDRome_DB.csv',index_col=0)\n",
    "df_idrome['is_enzyme'] = False\n",
    "df_idrome.loc[df_GO.query('GO_terms != 0').index,'is_enzyme'] = True \n",
    "\n",
    "df_idrome.query('is_enzyme').protein_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "496a9172",
   "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
}