Exp_fin_9_PPI_Modularity.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18815\n",
      "482935\n"
     ]
    }
   ],
   "source": [
    "## import os\n",
    "import sys\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "import itertools as it\n",
    "import random as rd\n",
    "import pickle as pk\n",
    "import os.path\n",
    "import pandas as pd\n",
    "from collections import (defaultdict,Counter)\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "# %matplotlib inline\n",
    "\n",
    "chem_vocabolary = pd.read_csv(\"input/CTD/CTD_chemicals_cleaned.txt\",delimiter= '\\t',\n",
    "           skipinitialspace=True)\n",
    "\n",
    "chem_gene_df = pd.read_csv(\"input/CTD/CTD_chem_gene_ixns.tsv\",delimiter= '\\t',\n",
    "            skipinitialspace=True)\n",
    "\n",
    "chem_homo = chem_gene_df[(chem_gene_df['Organism'] == 'Homo sapiens')]\n",
    "\n",
    "chem_gene = {}\n",
    "for i,v in chem_homo.iterrows():\n",
    "    try:\n",
    "        chem_gene[v[\"ChemicalID\"]] |= {v[\"GeneSymbol\"]}\n",
    "    except KeyError as e:\n",
    "        chem_gene[v[\"ChemicalID\"]] = set([v[\"GeneSymbol\"]])\n",
    "\n",
    "#Here, we remove the elements that do not perturb any genes:\n",
    "chem_gene_cleaned = {}\n",
    "tot_gene_list=[]\n",
    "for k,v in chem_gene.items():\n",
    "    if len(v)>0:\n",
    "        chem_gene_cleaned[k]=v\n",
    "        for gene in v:\n",
    "            tot_gene_list.append(gene)\n",
    "    else:\n",
    "        pass\n",
    "\n",
    "\n",
    "chem_voc_dict = {}\n",
    "for i,v in chem_vocabolary.iterrows():\n",
    "    try:\n",
    "        chem_voc_dict[v[\"ChemicalID\"]] = v[\"ParentIDs\"].split(\"|\")\n",
    "    except:\n",
    "        chem_voc_dict[v[\"ChemicalID\"]] = v[\"ParentIDs\"]\n",
    "\n",
    "from collections.abc import Mapping\n",
    "# Empty directed graph\n",
    "G = nx.DiGraph()\n",
    "\n",
    "for k in chem_voc_dict.keys():\n",
    "    try:\n",
    "        for v in chem_voc_dict[k]:\n",
    "            G.add_edge(k, v)\n",
    "    except:\n",
    "        G.add_edge(k,\"D\")\n",
    "\n",
    "classes_list=[]\n",
    "for i in G.nodes():\n",
    "    if len(nx.predecessor(G, i))==2:\n",
    "        classes_list.append(i)\n",
    "\n",
    "#Let's clean the list from the nan elements\n",
    "classes_list_cleaned = [x for x in classes_list if str(x) != 'nan']\n",
    "\n",
    "#Let's associate a specific color for each chemical group\n",
    "colors=['#D52EBF','#FFA1FF','#49CDAB','#AB9DF6','#7F41FF','#B74C6B','#00D99D','#43C9C2','#00F9FA','#DD66BD','#437FC2','#4BCDFF'] \n",
    "class_color_dict={}\n",
    "for i in range(len(classes_list_cleaned)):\n",
    "    class_color_dict[classes_list_cleaned[i]]=colors[i]\n",
    "    \n",
    "ppi = pd.read_csv(\"input/PPI/autocore_symbol_lcc.csv\",delimiter= ',',\n",
    "           skipinitialspace=True)\n",
    "\n",
    "G_ppi = nx.from_pandas_edgelist(ppi, 'symbol1', 'symbol2')\n",
    "\n",
    "G_ppi_lcc = G_ppi.subgraph(max(nx.connected_components(G_ppi), key=len))  # extract lcc graph\n",
    "print(G_ppi_lcc.number_of_nodes())\n",
    "print(G_ppi_lcc.number_of_edges())\n",
    "\n",
    "chem_gene_dictio_cleaned_ppi={}\n",
    "for k,v in chem_gene_cleaned.items():\n",
    "    new_list=[]\n",
    "    for gene in v:\n",
    "        if gene in G_ppi_lcc.nodes():\n",
    "            new_list.append(gene)\n",
    "        else:\n",
    "            pass\n",
    "    if len(new_list)>0:\n",
    "        chem_gene_dictio_cleaned_ppi[k]=new_list\n",
    "    else:\n",
    "        pass\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's import the EEN\n",
    "filtered_weighted_exp_graph_significant = nx.read_weighted_edgelist(\"output/backbone_exp_graph_significant_weighted.edgelist\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('output/chem_gene_hq.pickle', 'rb') as handle:\n",
    "    chem_gene_hq = pk.load(handle)\n",
    "with open('output/chem_gene_homo_mouse.pickle', 'rb') as handle:\n",
    "    chem_gene_homo_mouse = pk.load(handle)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "exposome_zscore={}\n",
    "\n",
    "for exp in chem_gene_dictio_cleaned_ppi.keys():\n",
    "    geneset = set(chem_gene_dictio_cleaned_ppi[exp])\n",
    "\n",
    "    G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "\n",
    "    G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "\n",
    "\n",
    "    f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "    l_random_lccs = []\n",
    "\n",
    "    S = 1000\n",
    "    for s in range(S):\n",
    "        gene_sample = rd.sample(G_ppi_lcc.nodes(),len(geneset))\n",
    "        G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "        G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "        lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "        l_random_lccs.append(lcc_size)\n",
    "    mu = np.mean(l_random_lccs)\n",
    "    std = np.std(l_random_lccs)\n",
    "\n",
    "    z = round(((f_lcc_size-mu)/std),3)\n",
    "\n",
    "\n",
    "    exposome_zscore[exp]=z\n",
    "\n",
    "with open('intermediate/exposome_zscore.pickle', 'wb') as handle:\n",
    "    pk.dump(exposome_zscore, handle, protocol=pk.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#We are importing here the dictionary that correspnds for each chemical a \n",
    "#z-score based on their connectivity (if exposure tends to perturb a well\n",
    "#localized neighborhood they will have a higher z-score)\n",
    "import pickle as pk\n",
    "with open('intermediate/exposome_zscore.pickle', 'rb') as handle:\n",
    "    exposome_zscore = pk.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-9-e3802fb73463>:24: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  z = round(((f_lcc_size-mu)/std),3)\n"
     ]
    }
   ],
   "source": [
    "add_exp_zscore={}\n",
    "for exp,z in exposome_zscore.items():\n",
    "    if str(z)==\"nan\" or str(z)==\"inf\":\n",
    "        if len(chem_gene_dictio_cleaned_ppi[exp])>1:\n",
    "            geneset = set(chem_gene_dictio_cleaned_ppi[exp])\n",
    "\n",
    "            G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "            G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "            \n",
    "            f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "            l_random_lccs = []\n",
    "\n",
    "            S = 1000\n",
    "            for s in range(S):\n",
    "                gene_sample = rd.sample(G_ppi_lcc.nodes(),len(geneset))\n",
    "                G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "                G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                l_random_lccs.append(lcc_size)\n",
    "            mu = np.mean(l_random_lccs)\n",
    "            std = np.std(l_random_lccs)\n",
    "\n",
    "            z = round(((f_lcc_size-mu)/std),3)\n",
    "            add_exp_zscore[exp]=z\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's do it one more time (the last one)\n",
    "add_add_exp_zscore={}\n",
    "for exp,z in add_exp_zscore.items():\n",
    "    if str(z)==\"nan\" or str(z)==\"inf\":\n",
    "        if len(chem_gene_dictio_cleaned_ppi[exp])>1:\n",
    "            geneset = set(chem_gene_dictio_cleaned_ppi[exp])\n",
    "\n",
    "            G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "            G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "            \n",
    "            f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "            l_random_lccs = []\n",
    "\n",
    "            S = 1000\n",
    "            for s in range(S):\n",
    "                gene_sample = rd.sample(G_ppi_lcc.nodes(),len(geneset))\n",
    "                G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "                G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                l_random_lccs.append(lcc_size)\n",
    "            mu = np.mean(l_random_lccs)\n",
    "            std = np.std(l_random_lccs)\n",
    "\n",
    "            z = round(((f_lcc_size-mu)/std),3)\n",
    "            add_add_exp_zscore[exp]=z\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's make a final z-score dict\n",
    "final_exposome_zscore={}\n",
    "for exp,z in exposome_zscore.items():\n",
    "    if len(chem_gene_dictio_cleaned_ppi[exp])>1:   #I remove those exposures that perturb just one gene\n",
    "        if str(z)!=\"nan\" and str(z)!=\"inf\":\n",
    "            final_exposome_zscore[exp]=z\n",
    "        else:\n",
    "            if str(add_exp_zscore[exp])!=\"nan\" and str(add_exp_zscore[exp])!=\"inf\":\n",
    "                final_exposome_zscore[exp]=add_exp_zscore[exp]\n",
    "            else:\n",
    "                final_exposome_zscore[exp]=add_add_exp_zscore[exp]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7177"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(final_exposome_zscore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('intermediate/final_exposome_zscore.pickle', 'wb') as handle:\n",
    "    pk.dump(final_exposome_zscore, handle, protocol=pk.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lets import it\n",
    "with open('intermediate/final_exposome_zscore.pickle', 'rb') as handle:\n",
    "    final_exposome_zscore = pk.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's look at the lcc z-score distribution of the final_exposome_zscore "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.LineCollection at 0x7ff407b06e50>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(15,15))\n",
    "plt.hist(list(final_exposome_zscore.values()), bins=50, alpha=0.5)\n",
    "\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.spines['bottom'].set_visible(True)\n",
    "ax.spines['left'].set_visible(True)\n",
    "#plt.xlabel('z-score',fontsize=22)\n",
    "#plt.ylabel('Frequency', fontsize=22)\n",
    "plt.yscale('log')\n",
    "plt.xticks(fontsize=36) \n",
    "plt.yticks(fontsize=36)\n",
    "plt.vlines(x=2,ymin=0,ymax=4000,color='r',label='statistically significance')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.717749616831544"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(list(final_exposome_zscore.values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.392"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(list(final_exposome_zscore.values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's compare now with the performance given by the communities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's import the renamed Louvain communities\n",
    "\n",
    "\n",
    "with open('output/Communities/Louvain/weighted_ji_fine_grained_communities_dict.pickle', 'rb') as handle:\n",
    "    fine_grained_communities_dict = pk.load(handle)   \n",
    "with open('output/Communities/Louvain/weighted_ji_middle_communities_dict.pickle', 'rb') as handle:\n",
    "    middle_communities_dict = pk.load(handle)       \n",
    "with open('output/Communities/Louvain/weighted_ji_broad_communities_dict.pickle', 'rb') as handle:\n",
    "    broad_communities_dict = pk.load(handle)       \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/0b/z0_jtrl111x5sn006y224x0w0000gq/T/ipykernel_38161/2620050837.py:34: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  z = round(((f_lcc_size-mu)/std),3)\n",
      "/var/folders/0b/z0_jtrl111x5sn006y224x0w0000gq/T/ipykernel_38161/2620050837.py:34: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  z = round(((f_lcc_size-mu)/std),3)\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import random as rd\n",
    "fine_grained_communities_lcc_zscore={}\n",
    "fine_grained_communities_genes_ppi={}\n",
    "for com,exp_list in fine_grained_communities_dict.items():\n",
    "    genelist=[]\n",
    "    for exp in exp_list:\n",
    "        try:\n",
    "            genelist.extend(chem_gene_dictio_cleaned_ppi[exp])\n",
    "        except:\n",
    "            pass\n",
    "    fine_grained_communities_genes_ppi[com]=set(genelist)\n",
    "    \n",
    "for com,geneset in fine_grained_communities_genes_ppi.items():\n",
    "    try:\n",
    "        G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "        G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "\n",
    "\n",
    "        f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "        l_random_lccs = []\n",
    "\n",
    "        S = 1000\n",
    "        for s in range(S):\n",
    "            gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "            G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "            G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "            lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "            l_random_lccs.append(lcc_size)\n",
    "        mu = np.mean(l_random_lccs)\n",
    "        std = np.std(l_random_lccs)\n",
    "\n",
    "        z = round(((f_lcc_size-mu)/std),3)\n",
    "    except:\n",
    "        z = 'nan'\n",
    "\n",
    "    fine_grained_communities_lcc_zscore[com]=z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "456"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(fine_grained_communities_lcc_zscore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "for com,z in fine_grained_communities_lcc_zscore.items():\n",
    "    if str(z)=='nan':\n",
    "        geneset=fine_grained_communities_genes_ppi[com]\n",
    "        if len(geneset)>3:\n",
    "            try:\n",
    "                G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "                G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "                f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "                l_random_lccs = []\n",
    "\n",
    "                S = 1000\n",
    "                for s in range(S):\n",
    "                    gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "                    G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "                    G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                    lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                    l_random_lccs.append(lcc_size)\n",
    "                mu = np.mean(l_random_lccs)\n",
    "                std = np.std(l_random_lccs)\n",
    "\n",
    "                z = round(((f_lcc_size-mu)/std),3)\n",
    "            except:\n",
    "                z = 'nan'\n",
    "        fine_grained_communities_lcc_zscore[com]=z\n",
    "    else:\n",
    "        pass\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import random as rd\n",
    "middle_communities_lcc_zscore={}\n",
    "middle_communities_genes_ppi={}\n",
    "for com,exp_list in middle_communities_dict.items():\n",
    "    genelist=[]\n",
    "    for exp in exp_list:\n",
    "        try:\n",
    "            genelist.extend(chem_gene_dictio_cleaned_ppi[exp])\n",
    "        except:\n",
    "            pass\n",
    "    middle_communities_genes_ppi[com]=set(genelist)\n",
    "    \n",
    "for com,geneset in middle_communities_genes_ppi.items():\n",
    "    try:\n",
    "        G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "        G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "\n",
    "\n",
    "        f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "        l_random_lccs = []\n",
    "\n",
    "        S = 1000\n",
    "        for s in range(S):\n",
    "            gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "            G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "            G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "            lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "            l_random_lccs.append(lcc_size)\n",
    "        mu = np.mean(l_random_lccs)\n",
    "        std = np.std(l_random_lccs)\n",
    "\n",
    "        z = round(((f_lcc_size-mu)/std),3)\n",
    "    except:\n",
    "        z = 'nan'\n",
    "\n",
    "    middle_communities_lcc_zscore[com]=z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "for com,z in middle_communities_lcc_zscore.items():\n",
    "    if str(z)=='nan':\n",
    "        geneset=middle_communities_genes_ppi[com]\n",
    "        if len(geneset)>3:\n",
    "            try:\n",
    "                G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "                G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "                f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "                l_random_lccs = []\n",
    "\n",
    "                S = 1000\n",
    "                for s in range(S):\n",
    "                    gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "                    G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "                    G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                    lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                    l_random_lccs.append(lcc_size)\n",
    "                mu = np.mean(l_random_lccs)\n",
    "                std = np.std(l_random_lccs)\n",
    "\n",
    "                z = round(((f_lcc_size-mu)/std),3)\n",
    "            except:\n",
    "                z = 'nan'\n",
    "        middle_communities_lcc_zscore[com]=z\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import random as rd\n",
    "broad_communities_lcc_zscore={}\n",
    "broad_communities_genes_ppi={}\n",
    "for com,exp_list in broad_communities_dict.items():\n",
    "    genelist=[]\n",
    "    for exp in exp_list:\n",
    "        try:\n",
    "            genelist.extend(chem_gene_dictio_cleaned_ppi[exp])\n",
    "        except:\n",
    "            pass\n",
    "    broad_communities_genes_ppi[com]=set(genelist)\n",
    "    \n",
    "for com,geneset in broad_communities_genes_ppi.items():\n",
    "    try:\n",
    "        G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "        G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "\n",
    "\n",
    "        f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "        l_random_lccs = []\n",
    "\n",
    "        S = 1000\n",
    "        for s in range(S):\n",
    "            gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "            G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "            G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "            lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "            l_random_lccs.append(lcc_size)\n",
    "        mu = np.mean(l_random_lccs)\n",
    "        std = np.std(l_random_lccs)\n",
    "\n",
    "        z = round(((f_lcc_size-mu)/std),3)\n",
    "    except:\n",
    "        z = 'nan'\n",
    "\n",
    "    broad_communities_lcc_zscore[com]=z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "for com,z in broad_communities_lcc_zscore.items():\n",
    "    if str(z)=='nan':\n",
    "        geneset=broad_communities_genes_ppi[com]\n",
    "        if len(geneset)>3:\n",
    "            try:\n",
    "                G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "                G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "                f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "                l_random_lccs = []\n",
    "\n",
    "                S = 1000\n",
    "                for s in range(S):\n",
    "                    gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "                    G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "                    G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                    lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                    l_random_lccs.append(lcc_size)\n",
    "                mu = np.mean(l_random_lccs)\n",
    "                std = np.std(l_random_lccs)\n",
    "\n",
    "                z = round(((f_lcc_size-mu)/std),3)\n",
    "            except:\n",
    "                z = 'nan'\n",
    "        broad_communities_lcc_zscore[com]=z\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "lcc_zscore_df=pd.DataFrame()\n",
    "\n",
    "category_list=[]\n",
    "zscore_list=[]\n",
    "for z in [v for v in final_exposome_zscore.values() if str(v)!='nan' and str(v)!='inf']:\n",
    "    zscore_list.append(z)\n",
    "    category_list.append(\"all exposures\")\n",
    " \n",
    "for z in [v for v in fine_grained_communities_lcc_zscore.values() if str(v)!='nan' and str(v)!='inf']:\n",
    "    zscore_list.append(z)\n",
    "    category_list.append(\"fine-grained\")\n",
    "\n",
    "for z in [v for v in middle_communities_lcc_zscore.values() if str(v)!='nan' and str(v)!='inf']:\n",
    "    zscore_list.append(z)\n",
    "    category_list.append(\"intermediate\")   \n",
    "    \n",
    "for z in [v for v in broad_communities_lcc_zscore.values() if str(v)!='nan' and str(v)!='inf']:\n",
    "    zscore_list.append(z)\n",
    "    category_list.append(\"broad\")    \n",
    "\n",
    "lcc_zscore_df['group']=category_list\n",
    "lcc_zscore_df['z-score']=zscore_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from joypy import joyplot\n",
    "import seaborn as sns\n",
    "\n",
    "joyplot(lcc_zscore_df, by='group', column='z-score',colormap=sns.color_palette(\"crest\", as_cmap=True));\n",
    "\n",
    "plt.xlabel('z-score');\n",
    "plt.vlines(x=2,ymin=0,ymax=1,color='r',label='statistically significance',zorder=10);\n",
    "plt.savefig('output/Figures/Fig3D_v01_post_rev.pdf',format='pdf',dpi=300, bbox_inches = \"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x1400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Let's do it again, but this time we plot the number of exposures that are associated with a statistically significant\n",
    "#neighborhood and not those that we lose\n",
    "\n",
    "\n",
    "from matplotlib.ticker import FuncFormatter\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from matplotlib.pyplot import figure\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "fig1, ax1 = plt.subplots(figsize=(14, 14))\n",
    "\n",
    "x = np.arange(2)\n",
    "\n",
    "ax1.spines['top'].set_visible(False)\n",
    "ax1.spines['right'].set_visible(False)\n",
    "ax1.spines['bottom'].set_visible(True)\n",
    "ax1.spines['left'].set_visible(True)\n",
    "\n",
    "not_module_exposure_list=[]\n",
    "tot_backboneexposures=filtered_weighted_exp_graph_significant.number_of_nodes()\n",
    "\n",
    "for exp in filtered_weighted_exp_graph_significant.nodes():\n",
    "    try:\n",
    "        if float(final_exposome_zscore[exp])<2:\n",
    "            not_module_exposure_list.append(exp)\n",
    "        else:\n",
    "            pass\n",
    "    except:\n",
    "        not_module_exposure_list.append(exp)\n",
    "\n",
    "not_module_exposure_com_list=[]\n",
    "for exp in filtered_weighted_exp_graph_significant.nodes():\n",
    "    for com,explist in fine_grained_communities_dict.items():\n",
    "        if exp in explist:\n",
    "            if float(fine_grained_communities_lcc_zscore[com])<2:\n",
    "                for com2,explist2 in middle_communities_dict.items():\n",
    "                    if exp in explist2:\n",
    "                        if float(middle_communities_lcc_zscore[com2])<2:\n",
    "                            for com3,explist3 in broad_communities_dict.items():\n",
    "                                if exp in explist3:\n",
    "                                    if float(broad_communities_lcc_zscore[com3])<2:\n",
    "                                        not_module_exposure_com_list.append(exp)\n",
    "                \n",
    "\n",
    "module_exposure_list_tot=[tot_backboneexposures-len(not_module_exposure_list),tot_backboneexposures-len(not_module_exposure_com_list)]\n",
    "label=['All exposures', 'Community-based']\n",
    "\n",
    "    \n",
    "plt.barh(x, module_exposure_list_tot,color='#5F5F5F')\n",
    "#plt.title('Frequency of exposures rank by their degree',fontsize=32)\n",
    "#plt.ylabel('Frequency',fontsize=20)\n",
    "#plt.xlabel('Number of exposures',fontsize=45)\n",
    "plt.xticks(fontsize=45,rotation=45)\n",
    "plt.yticks(x, label,fontsize=36,ha='right')\n",
    "#plt.yticks([],fontsize=45,rotation=45,ha='right')\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig('output/Figures/Fig3E_v01_post_rev.pdf',format='pdf',dpi=300, bbox_inches = \"tight\")\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Infomap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's import the infomap communities\n",
    "\n",
    "with open('output/Communities/Infomap/ji_infomap_fine_grained_communities_dict.pickle', 'rb') as handle:\n",
    "    fine_grained_communities_dict = pk.load(handle)\n",
    "with open('output/Communities/Infomap/ji_infomap_middle_communities_dict.pickle', 'rb') as handle:\n",
    "    middle_communities_dict = pk.load(handle)\n",
    "with open('output/Communities/Infomap/ji_infomap_broad_communities_dict.pickle', 'rb') as handle:\n",
    "    broad_communities_dict = pk.load(handle)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/0b/z0_jtrl111x5sn006y224x0w0000gq/T/ipykernel_34140/2620050837.py:34: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  z = round(((f_lcc_size-mu)/std),3)\n",
      "/var/folders/0b/z0_jtrl111x5sn006y224x0w0000gq/T/ipykernel_34140/2620050837.py:34: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  z = round(((f_lcc_size-mu)/std),3)\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import random as rd\n",
    "fine_grained_communities_lcc_zscore={}\n",
    "fine_grained_communities_genes_ppi={}\n",
    "for com,exp_list in fine_grained_communities_dict.items():\n",
    "    genelist=[]\n",
    "    for exp in exp_list:\n",
    "        try:\n",
    "            genelist.extend(chem_gene_dictio_cleaned_ppi[exp])\n",
    "        except:\n",
    "            pass\n",
    "    fine_grained_communities_genes_ppi[com]=set(genelist)\n",
    "    \n",
    "for com,geneset in fine_grained_communities_genes_ppi.items():\n",
    "    try:\n",
    "        G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "        G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "\n",
    "\n",
    "        f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "        l_random_lccs = []\n",
    "\n",
    "        S = 1000\n",
    "        for s in range(S):\n",
    "            gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "            G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "            G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "            lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "            l_random_lccs.append(lcc_size)\n",
    "        mu = np.mean(l_random_lccs)\n",
    "        std = np.std(l_random_lccs)\n",
    "\n",
    "        z = round(((f_lcc_size-mu)/std),3)\n",
    "    except:\n",
    "        z = 'nan'\n",
    "\n",
    "    fine_grained_communities_lcc_zscore[com]=z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "for com,z in fine_grained_communities_lcc_zscore.items():\n",
    "    if str(z)=='nan':\n",
    "        geneset=fine_grained_communities_genes_ppi[com]\n",
    "        if len(geneset)>3:\n",
    "            try:\n",
    "                G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "                G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "                f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "                l_random_lccs = []\n",
    "\n",
    "                S = 1000\n",
    "                for s in range(S):\n",
    "                    gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "                    G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "                    G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                    lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                    l_random_lccs.append(lcc_size)\n",
    "                mu = np.mean(l_random_lccs)\n",
    "                std = np.std(l_random_lccs)\n",
    "\n",
    "                z = round(((f_lcc_size-mu)/std),3)\n",
    "            except:\n",
    "                z = 'nan'\n",
    "        fine_grained_communities_lcc_zscore[com]=z\n",
    "    else:\n",
    "        pass\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import random as rd\n",
    "middle_communities_lcc_zscore={}\n",
    "middle_communities_genes_ppi={}\n",
    "for com,exp_list in middle_communities_dict.items():\n",
    "    genelist=[]\n",
    "    for exp in exp_list:\n",
    "        try:\n",
    "            genelist.extend(chem_gene_dictio_cleaned_ppi[exp])\n",
    "        except:\n",
    "            pass\n",
    "    middle_communities_genes_ppi[com]=set(genelist)\n",
    "    \n",
    "for com,geneset in middle_communities_genes_ppi.items():\n",
    "    try:\n",
    "        G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "        G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "\n",
    "\n",
    "        f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "        l_random_lccs = []\n",
    "\n",
    "        S = 1000\n",
    "        for s in range(S):\n",
    "            gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "            G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "            G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "            lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "            l_random_lccs.append(lcc_size)\n",
    "        mu = np.mean(l_random_lccs)\n",
    "        std = np.std(l_random_lccs)\n",
    "\n",
    "        z = round(((f_lcc_size-mu)/std),3)\n",
    "    except:\n",
    "        z = 'nan'\n",
    "\n",
    "    middle_communities_lcc_zscore[com]=z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "for com,z in middle_communities_lcc_zscore.items():\n",
    "    if str(z)=='nan':\n",
    "        geneset=middle_communities_genes_ppi[com]\n",
    "        if len(geneset)>3:\n",
    "            try:\n",
    "                G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "                G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "                f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "                l_random_lccs = []\n",
    "\n",
    "                S = 1000\n",
    "                for s in range(S):\n",
    "                    gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "                    G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "                    G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                    lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                    l_random_lccs.append(lcc_size)\n",
    "                mu = np.mean(l_random_lccs)\n",
    "                std = np.std(l_random_lccs)\n",
    "\n",
    "                z = round(((f_lcc_size-mu)/std),3)\n",
    "            except:\n",
    "                z = 'nan'\n",
    "        middle_communities_lcc_zscore[com]=z\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import random as rd\n",
    "broad_communities_lcc_zscore={}\n",
    "broad_communities_genes_ppi={}\n",
    "for com,exp_list in broad_communities_dict.items():\n",
    "    genelist=[]\n",
    "    for exp in exp_list:\n",
    "        try:\n",
    "            genelist.extend(chem_gene_dictio_cleaned_ppi[exp])\n",
    "        except:\n",
    "            pass\n",
    "    broad_communities_genes_ppi[com]=set(genelist)\n",
    "    \n",
    "for com,geneset in broad_communities_genes_ppi.items():\n",
    "    try:\n",
    "        G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "        G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "\n",
    "\n",
    "        f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "        l_random_lccs = []\n",
    "\n",
    "        S = 1000\n",
    "        for s in range(S):\n",
    "            gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "            G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "            G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "            lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "            l_random_lccs.append(lcc_size)\n",
    "        mu = np.mean(l_random_lccs)\n",
    "        std = np.std(l_random_lccs)\n",
    "\n",
    "        z = round(((f_lcc_size-mu)/std),3)\n",
    "    except:\n",
    "        z = 'nan'\n",
    "\n",
    "    broad_communities_lcc_zscore[com]=z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "for com,z in broad_communities_lcc_zscore.items():\n",
    "    if str(z)=='nan':\n",
    "        geneset=broad_communities_genes_ppi[com]\n",
    "        if len(geneset)>3:\n",
    "            try:\n",
    "                G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "                G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "                f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "                l_random_lccs = []\n",
    "\n",
    "                S = 1000\n",
    "                for s in range(S):\n",
    "                    gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "                    G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "                    G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                    lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                    l_random_lccs.append(lcc_size)\n",
    "                mu = np.mean(l_random_lccs)\n",
    "                std = np.std(l_random_lccs)\n",
    "\n",
    "                z = round(((f_lcc_size-mu)/std),3)\n",
    "            except:\n",
    "                z = 'nan'\n",
    "        broad_communities_lcc_zscore[com]=z\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "lcc_zscore_df=pd.DataFrame()\n",
    "\n",
    "category_list=[]\n",
    "zscore_list=[]\n",
    "for z in [v for v in final_exposome_zscore.values() if str(v)!='nan' and str(v)!='inf']:\n",
    "    zscore_list.append(z)\n",
    "    category_list.append(\"all exposures\")\n",
    " \n",
    "for z in [v for v in fine_grained_communities_lcc_zscore.values() if str(v)!='nan' and str(v)!='inf']:\n",
    "    zscore_list.append(z)\n",
    "    category_list.append(\"fine-grained\")\n",
    "\n",
    "for z in [v for v in middle_communities_lcc_zscore.values() if str(v)!='nan' and str(v)!='inf']:\n",
    "    zscore_list.append(z)\n",
    "    category_list.append(\"intermediate\")   \n",
    "    \n",
    "for z in [v for v in broad_communities_lcc_zscore.values() if str(v)!='nan' and str(v)!='inf']:\n",
    "    zscore_list.append(z)\n",
    "    category_list.append(\"broad\")    \n",
    "\n",
    "lcc_zscore_df['group']=category_list\n",
    "lcc_zscore_df['z-score']=zscore_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from joypy import joyplot\n",
    "import seaborn as sns\n",
    "\n",
    "joyplot(lcc_zscore_df, by='group', kind = \"normalized_counts\",column='z-score',colormap=sns.color_palette(\"crest\", as_cmap=True));\n",
    "\n",
    "plt.xlabel('z-score');\n",
    "plt.vlines(x=2,ymin=0,ymax=1,color='r',label='statistically significance',zorder=10);\n",
    "plt.savefig('output/Figures/SF16E_v01_post_rev.pdf',format='pdf',dpi=300, bbox_inches = \"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Here we define the 90* percentile of the degree distribution\n",
    "degree_list=[]\n",
    "for i in G_ppi_lcc.nodes():\n",
    "    degree_list.append(G_ppi_lcc.degree[i])\n",
    "a = np.array(degree_list)\n",
    "degree_90percentile = np.percentile(a, 90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's check if an exposure form a module, if it doesn't then we will check if it targets an hub gene\n",
    "hub_exposures={}\n",
    "exp_significant_modules={}\n",
    "for k,v in exposome_zscore.items():\n",
    "    if float(v)>2:\n",
    "        exp_significant_modules[k]=v\n",
    "    else:\n",
    "        geneset=chem_gene_dictio_cleaned_ppi[k]\n",
    "        geneset_degree=[]\n",
    "        for gene in geneset:\n",
    "            geneset_degree.append(G_ppi_lcc.degree[gene])\n",
    "            if any(y > degree_90percentile for y in geneset_degree):\n",
    "                    hub_exposures[k]=v\n",
    "            else:\n",
    "                pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "exp_significant_modules_central={}\n",
    "exp_significant_modules_peripheric={}\n",
    "for k,v in exp_significant_modules.items():\n",
    "    geneset=chem_gene_dictio_cleaned_ppi[k]\n",
    "    geneset_degree=[]\n",
    "    for gene in geneset:\n",
    "        geneset_degree.append(G_ppi_lcc.degree[gene])\n",
    "    if any(y > degree_90percentile for y in geneset_degree):\n",
    "        exp_significant_modules_central[k]=v\n",
    "    else:\n",
    "        exp_significant_modules_peripheric[k]=v\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "hub_exp_ss_module=set(list(exp_significant_modules.keys())+list(hub_exposures.keys()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "no_central_no_module=[]\n",
    "for k,v in exposome_zscore.items():\n",
    "    if k not in hub_exp_ss_module:\n",
    "        no_central_no_module.append(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3370"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set(no_central_no_module))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/No_central_no_module_exposures.txt', 'w')\n",
    "\n",
    "for exp in no_central_no_module:\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/Hub_expusres.txt', 'w')\n",
    "\n",
    "for exp in list(hub_exposures.keys()):\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/Central_module_exposures.txt', 'w')\n",
    "\n",
    "for exp in list(exp_significant_modules_central.keys()):\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/Peripheric_module_exposures.txt', 'w')\n",
    "\n",
    "for exp in list(exp_significant_modules_peripheric.keys()):\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "peripheric_module_exp_zscore=[]\n",
    "peripheric_module_exp=[]\n",
    "for k,v in classes_zscore_peripheric_module.items():\n",
    "    peripheric_module_exp.extend(v)\n",
    "peripheric_module_exp_unique=set(peripheric_module_exp)\n",
    "for exp in peripheric_module_exp_unique:\n",
    "    peripheric_module_exp_zscore.append(exp_significant_modules[exp])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "central_module_exp_zscore=[]\n",
    "central_module_exp=[]\n",
    "for k,v in classes_zscore_central_module.items():\n",
    "    central_module_exp.extend(v)\n",
    "central_module_exp_unique=set(central_module_exp)\n",
    "for exp in central_module_exp_unique:\n",
    "    central_module_exp_zscore.append(exp_significant_modules[exp])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "AttributeError",
     "evalue": "'NoneType' object has no attribute 'lower'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-44-fbbf4ceff8c4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;31m# show plot\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstats\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmannwhitneyu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcentral_module_exp_zscore\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mperipheric_module_exp_zscore\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse_continuity\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malternative\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/scipy/stats/_mannwhitneyu.py\u001b[0m in \u001b[0;36mmannwhitneyu\u001b[0;34m(x, y, use_continuity, alternative, axis, method)\u001b[0m\n\u001b[1;32m    389\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    390\u001b[0m     x, y, use_continuity, alternative, axis_int, method = (\n\u001b[0;32m--> 391\u001b[0;31m         _mwu_input_validation(x, y, use_continuity, alternative, axis, method))\n\u001b[0m\u001b[1;32m    392\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    393\u001b[0m     \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_broadcast_concatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/scipy/stats/_mannwhitneyu.py\u001b[0m in \u001b[0;36m_mwu_input_validation\u001b[0;34m(x, y, use_continuity, alternative, axis, method)\u001b[0m\n\u001b[1;32m    140\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    141\u001b[0m     \u001b[0malternatives\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"two-sided\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"less\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"greater\"\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 142\u001b[0;31m     \u001b[0malternative\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0malternative\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    143\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0malternative\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0malternatives\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    144\u001b[0m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'`alternative` must be one of {alternatives}.'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'lower'"
     ]
    }
   ],
   "source": [
    "import scipy\n",
    "module_exp=[central_module_exp_zscore,peripheric_module_exp_zscore]\n",
    "fig = plt.figure(figsize =(10, 7))\n",
    " \n",
    "# Creating axes instance\n",
    "ax = fig.add_subplot(111)\n",
    " \n",
    "# Creating plot\n",
    "bp = ax.boxplot(module_exp)\n",
    "\n",
    "ax.set_xticklabels(['central modules', 'peripheric modules'])\n",
    "ax.set_ylabel('z-score')\n",
    "# show plot\n",
    "plt.show()\n",
    "print(scipy.stats.mannwhitneyu(central_module_exp_zscore, peripheric_module_exp_zscore, use_continuity=True, alternative='two-sided'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/0b/z0_jtrl111x5sn006y224x0w0000gq/T/ipykernel_38161/2071291305.py:41: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  z = round(((f_lcc_size-mu)/std),3)\n",
      "/var/folders/0b/z0_jtrl111x5sn006y224x0w0000gq/T/ipykernel_38161/2071291305.py:41: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  z = round(((f_lcc_size-mu)/std),3)\n"
     ]
    }
   ],
   "source": [
    "#Let's repeat for the perturbation case\n",
    "\n",
    "#chem_gene_hq\n",
    "\n",
    "\n",
    "chem_gene_hq_ppi={}\n",
    "for k,v in chem_gene_hq.items():\n",
    "    new_list=[]\n",
    "    for gene in v:\n",
    "        if gene in G_ppi_lcc.nodes():\n",
    "            new_list.append(gene)\n",
    "        else:\n",
    "            pass\n",
    "    if len(new_list)>0:\n",
    "        chem_gene_hq_ppi[k]=new_list\n",
    "    else:\n",
    "        pass\n",
    "\n",
    "\n",
    "import math\n",
    "chem_gene_hq_ppi_zscore={}\n",
    "\n",
    "for exp in chem_gene_hq_ppi.keys():\n",
    "    geneset = set(chem_gene_hq_ppi[exp])\n",
    "    G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "    G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "\n",
    "    f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "    l_random_lccs = []\n",
    "\n",
    "    S = 1000\n",
    "    for s in range(S):\n",
    "        gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "        G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "        G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "        lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "        l_random_lccs.append(lcc_size)\n",
    "    mu = np.mean(l_random_lccs)\n",
    "    std = np.std(l_random_lccs)\n",
    "\n",
    "    z = round(((f_lcc_size-mu)/std),3)\n",
    "\n",
    "    chem_gene_hq_ppi_zscore[exp]=z\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2910"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(chem_gene_hq_ppi_zscore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2910"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(chem_gene_hq_ppi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/0b/z0_jtrl111x5sn006y224x0w0000gq/T/ipykernel_38161/1021679818.py:23: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  z = round(((f_lcc_size-mu)/std),3)\n",
      "/var/folders/0b/z0_jtrl111x5sn006y224x0w0000gq/T/ipykernel_38161/1021679818.py:23: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  z = round(((f_lcc_size-mu)/std),3)\n"
     ]
    }
   ],
   "source": [
    "add_chem_gene_hq_ppi_zscore={}\n",
    "for exp,z in chem_gene_hq_ppi_zscore.items():\n",
    "    if str(z)==\"nan\" or str(z)==\"inf\":\n",
    "        if len(chem_gene_hq_ppi[exp])>1:\n",
    "            geneset = set(chem_gene_hq_ppi[exp])\n",
    "            G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "            G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "            \n",
    "            f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "            l_random_lccs = []\n",
    "\n",
    "            S = 1000\n",
    "            for s in range(S):\n",
    "                gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "                G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "                G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                l_random_lccs.append(lcc_size)\n",
    "            mu = np.mean(l_random_lccs)\n",
    "            std = np.std(l_random_lccs)\n",
    "\n",
    "            z = round(((f_lcc_size-mu)/std),3)\n",
    "            add_chem_gene_hq_ppi_zscore[exp]=z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's do it one more time (the last one)\n",
    "add_add_chem_gene_hq_ppi_zscore = {}\n",
    "for exp,z in add_chem_gene_hq_ppi_zscore.items():\n",
    "    if str(z)==\"nan\" or str(z)==\"inf\":\n",
    "        if len(chem_gene_hq_ppi[exp])>1:\n",
    "            geneset = set(chem_gene_hq_ppi[exp])\n",
    "\n",
    "            G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "            G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "            \n",
    "            f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "            l_random_lccs = []\n",
    "\n",
    "            S = 1000\n",
    "            for s in range(S):\n",
    "                gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "                G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "\n",
    "                G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                l_random_lccs.append(lcc_size)\n",
    "            mu = np.mean(l_random_lccs)\n",
    "            std = np.std(l_random_lccs)\n",
    "\n",
    "            z = round(((f_lcc_size-mu)/std),3)\n",
    "            add_add_chem_gene_hq_ppi_zscore[exp]=z\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's make a final z-score dict\n",
    "final_chem_gene_hq_ppi_zscore={}\n",
    "for exp,z in chem_gene_hq_ppi_zscore.items():\n",
    "    if len(chem_gene_hq_ppi[exp])>1:   #I remove those exposures that perturb just one gene\n",
    "        if str(z)!=\"nan\" and str(z)!=\"inf\":\n",
    "            final_chem_gene_hq_ppi_zscore[exp]=z\n",
    "        else:\n",
    "            if str(add_chem_gene_hq_ppi_zscore[exp])!=\"nan\" and str(add_chem_gene_hq_ppi_zscore[exp])!=\"inf\":\n",
    "                final_chem_gene_hq_ppi_zscore[exp]=add_chem_gene_hq_ppi_zscore[exp]\n",
    "            else:\n",
    "                final_chem_gene_hq_ppi_zscore[exp]=add_add_chem_gene_hq_ppi_zscore[exp]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1808"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(final_chem_gene_hq_ppi_zscore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('intermediate/final_chem_gene_hq_ppi_zscore.pickle', 'wb') as handle:\n",
    "    pk.dump(final_chem_gene_hq_ppi_zscore, handle, protocol=pk.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "chem_gene_hq_hub_exposures={}\n",
    "chem_gene_hq_exp_significant_modules={}\n",
    "for k,v in final_chem_gene_hq_ppi_zscore.items():\n",
    "    if float(v)>2:\n",
    "        chem_gene_hq_exp_significant_modules[k]=v\n",
    "    else:\n",
    "        geneset=chem_gene_hq_ppi[k]\n",
    "        geneset_degree=[]\n",
    "        for gene in geneset:\n",
    "            geneset_degree.append(G_ppi_lcc.degree[gene])\n",
    "            if any(y > degree_90percentile for y in geneset_degree):\n",
    "                    chem_gene_hq_hub_exposures[k]=v\n",
    "            else:\n",
    "                pass\n",
    "\n",
    "chem_gene_hq_exp_significant_modules_central={}\n",
    "chem_gene_hq_exp_significant_modules_peripheric={}\n",
    "for k,v in chem_gene_hq_exp_significant_modules.items():\n",
    "    geneset=chem_gene_hq_ppi[k]\n",
    "    geneset_degree=[]\n",
    "    for gene in geneset:\n",
    "        geneset_degree.append(G_ppi_lcc.degree[gene])\n",
    "    if any(y > degree_90percentile for y in geneset_degree):\n",
    "        chem_gene_hq_exp_significant_modules_central[k]=v\n",
    "    else:\n",
    "        chem_gene_hq_exp_significant_modules_peripheric[k]=v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1398\n",
      "288\n",
      "1045\n",
      "179\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "chem_gene_hq_exp_no_central_no_module = []\n",
    "\n",
    "for chem in chem_gene_hq_ppi.keys():\n",
    "    if chem not in chem_gene_hq_exp_significant_modules.keys() and chem not in chem_gene_hq_hub_exposures.keys():\n",
    "        chem_gene_hq_exp_no_central_no_module.append(chem)\n",
    "\n",
    "\n",
    "print(len(chem_gene_hq_exp_no_central_no_module))\n",
    "print(len(chem_gene_hq_hub_exposures))\n",
    "print(len(chem_gene_hq_exp_significant_modules_central))\n",
    "print(len(chem_gene_hq_exp_significant_modules_peripheric))\n",
    "\n",
    "print(len(chem_gene_hq_exp_no_central_no_module)+len(chem_gene_hq_hub_exposures)+len(chem_gene_hq_exp_significant_modules_central)+len(chem_gene_hq_exp_significant_modules_peripheric)==len(chem_gene_hq_ppi))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x2000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Here, we show the proportion of the chemical classes in the entire CTD \n",
    "fig, ax = plt.subplots(figsize=(10, 20), subplot_kw=dict(aspect=\"equal\"))\n",
    "radius = 1\n",
    "\n",
    "cmap = plt.cm.viridis\n",
    "\n",
    "\n",
    "sizes=[len(chem_gene_hq_hub_exposures),len(chem_gene_hq_exp_significant_modules_central),len(chem_gene_hq_exp_significant_modules_peripheric),len(chem_gene_hq_exp_no_central_no_module)]\n",
    "\n",
    "wedges, texts = ax.pie(sizes, wedgeprops=dict(width=1), startangle=-125)\n",
    "\n",
    "bbox_props = dict(boxstyle=\"square,pad=0.2\", fc=\"w\", ec=\"k\", lw=1.72)\n",
    "kw = dict(arrowprops=dict(arrowstyle=\"-\"),\n",
    "          bbox=bbox_props, zorder=0, va=\"center\")\n",
    "\n",
    "#for i, p in enumerate(wedges):\n",
    "#    ang = (p.theta2 - p.theta1)/2. + p.theta1\n",
    "#    y = np.sin(np.deg2rad(ang))\n",
    "#    x = np.cos(np.deg2rad(ang))\n",
    "#    horizontalalignment = {-1: \"right\", 1: \"left\"}[int(np.sign(x))]\n",
    "#    connectionstyle = \"angle,angleA=0,angleB={}\".format(ang)\n",
    "#    kw[\"arrowprops\"].update({\"connectionstyle\": connectionstyle})\n",
    "#    ax.annotate(labels[i], xy=(x, y), xytext=(1.8*np.sign(x), 2.5*y),\n",
    "#                horizontalalignment=horizontalalignment,fontsize=24, **kw)\n",
    "plt.savefig('output/Figures/SF7A_v01_post_rev.pdf',format='pdf',dpi=300, bbox_inches = \"tight\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/HomoHQ_No_central_no_module_exposures.txt', 'w')\n",
    "\n",
    "for exp in chem_gene_hq_exp_no_central_no_module:\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/HomoHQ_Hub_exposures.txt', 'w')\n",
    "\n",
    "for exp in list(chem_gene_hq_hub_exposures.keys()):\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/HomoHQ_Central_module_exposures.txt', 'w')\n",
    "\n",
    "for exp in list(chem_gene_hq_exp_significant_modules_central.keys()):\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/HomoHQ_Peripheric_module_exposures.txt', 'w')\n",
    "\n",
    "for exp in list(chem_gene_hq_exp_significant_modules_peripheric.keys()):\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "#chem_gene_homo_mouse\n",
    "chem_gene_homo_mouse_ppi={}\n",
    "for k,v in chem_gene_homo_mouse.items():\n",
    "    new_list=[]\n",
    "    for gene in v:\n",
    "        if gene in G_ppi_lcc.nodes():\n",
    "            new_list.append(gene)\n",
    "        else:\n",
    "            pass\n",
    "    if len(new_list)>0:\n",
    "        chem_gene_homo_mouse_ppi[k]=new_list\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "chem_gene_homo_mouse_ppi_zscore={}\n",
    "\n",
    "for exp in chem_gene_homo_mouse_ppi.keys():\n",
    "    if len(chem_gene_homo_mouse_ppi[exp])>1: #let's exclude those exposures that perturb only one gene\n",
    "        geneset = set(chem_gene_homo_mouse_ppi[exp])\n",
    "        G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "        G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "        f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "        l_random_lccs = []\n",
    "        S = 1000\n",
    "        for s in range(S):\n",
    "            gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "            G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "            G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "            lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "            l_random_lccs.append(lcc_size)\n",
    "        mu = np.mean(l_random_lccs)\n",
    "        std = np.std(l_random_lccs)\n",
    "        z = round(((f_lcc_size-mu)/std),3)\n",
    "        chem_gene_homo_mouse_ppi_zscore[exp]=z\n",
    "\n",
    "\n",
    "add_chem_gene_homo_mouse_ppi_zscore={}\n",
    "for exp,z in chem_gene_homo_mouse_ppi_zscore.items():\n",
    "    if str(z)==\"nan\" or str(z)==\"inf\":\n",
    "        if len(chem_gene_homo_mouse_ppi[exp])>1:\n",
    "            geneset = set(chem_gene_homo_mouse_ppi[exp])\n",
    "            G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "            G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "            f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "            l_random_lccs = []\n",
    "            S = 1000\n",
    "            for s in range(S):\n",
    "                gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "                G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "                G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                l_random_lccs.append(lcc_size)\n",
    "            mu = np.mean(l_random_lccs)\n",
    "            std = np.std(l_random_lccs)\n",
    "            z = round(((f_lcc_size-mu)/std),3)\n",
    "            add_chem_gene_homo_mouse_ppi_zscore[exp]=z\n",
    "\n",
    "\n",
    "add_add_chem_gene_homo_mouse_ppi_zscore = {}\n",
    "for exp,z in add_chem_gene_homo_mouse_ppi_zscore.items():\n",
    "    if str(z)==\"nan\" or str(z)==\"inf\":\n",
    "        if len(chem_gene_homo_mouse_ppi[exp])>1:\n",
    "            geneset = set(chem_gene_homo_mouse_ppi[exp])\n",
    "            G_sub = nx.subgraph(G_ppi_lcc,geneset)\n",
    "            G_sub_lcc = G_sub.subgraph(max(nx.connected_components(G_sub), key=len))  # extract lcc graph\n",
    "            f_lcc_size = G_sub_lcc.number_of_nodes()\n",
    "            l_random_lccs = []\n",
    "            S = 1000\n",
    "            for s in range(S):\n",
    "                gene_sample = rd.sample(list(G_ppi_lcc.nodes()),len(geneset))\n",
    "                G_sub_rnd = nx.subgraph(G_ppi_lcc,gene_sample)\n",
    "                G_sub_rnd_lcc = G_sub_rnd.subgraph(max(nx.connected_components(G_sub_rnd), key=len))  # extract lcc graph\n",
    "                lcc_size = G_sub_rnd_lcc.number_of_nodes()\n",
    "                l_random_lccs.append(lcc_size)\n",
    "            mu = np.mean(l_random_lccs)\n",
    "            std = np.std(l_random_lccs)\n",
    "            z = round(((f_lcc_size-mu)/std),3)\n",
    "            add_add_chem_gene_homo_mouse_ppi_zscore[exp]=z\n",
    "\n",
    "\n",
    "final_chem_gene_homo_mouse_ppi_zscore={}\n",
    "for exp,z in chem_gene_homo_mouse_ppi_zscore.items():\n",
    "    if len(chem_gene_homo_mouse_ppi[exp])>1:   #I remove those exposures that perturb just one gene\n",
    "        if str(z)!=\"nan\" and str(z)!=\"inf\":\n",
    "            final_chem_gene_homo_mouse_ppi_zscore[exp]=z\n",
    "        else:\n",
    "            if str(add_chem_gene_homo_mouse_ppi_zscore[exp])!=\"nan\" and str(add_chem_gene_homo_mouse_ppi_zscore[exp])!=\"inf\":\n",
    "                final_chem_gene_homo_mouse_ppi_zscore[exp]=add_chem_gene_homo_mouse_ppi_zscore[exp]\n",
    "            else:\n",
    "                final_chem_gene_homo_mouse_ppi_zscore[exp]=add_add_chem_gene_homo_mouse_ppi_zscore[exp]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('intermediate/final_chem_gene_homo_mouse_ppi_zscore.pickle', 'wb') as handle:\n",
    "    pk.dump(final_chem_gene_homo_mouse_ppi_zscore, handle, protocol=pk.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('intermediate/final_chem_gene_homo_mouse_ppi_zscore.pickle', 'rb') as handle:\n",
    "    final_chem_gene_homo_mouse_ppi_zscore = pk.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "chem_gene_homo_mouse_ppi_hub_exposures={}\n",
    "chem_gene_homo_mouse_ppi_exp_significant_modules={}\n",
    "for k,v in final_chem_gene_homo_mouse_ppi_zscore.items():\n",
    "    if float(v)>2:\n",
    "        chem_gene_homo_mouse_ppi_exp_significant_modules[k]=v\n",
    "    else:\n",
    "        geneset=chem_gene_homo_mouse_ppi[k]\n",
    "        geneset_degree=[]\n",
    "        for gene in geneset:\n",
    "            geneset_degree.append(G_ppi_lcc.degree[gene])\n",
    "            if any(y > degree_90percentile for y in geneset_degree):\n",
    "                    chem_gene_homo_mouse_ppi_hub_exposures[k]=v\n",
    "            else:\n",
    "                pass\n",
    "\n",
    "chem_gene_homo_mouse_ppi_exp_significant_modules_central={}\n",
    "chem_gene_homo_mouse_ppi_exp_significant_modules_peripheric={}\n",
    "for k,v in chem_gene_homo_mouse_ppi_exp_significant_modules.items():\n",
    "    geneset=chem_gene_homo_mouse_ppi[k]\n",
    "    geneset_degree=[]\n",
    "    for gene in geneset:\n",
    "        geneset_degree.append(G_ppi_lcc.degree[gene])\n",
    "    if any(y > degree_90percentile for y in geneset_degree):\n",
    "        chem_gene_homo_mouse_ppi_exp_significant_modules_central[k]=v\n",
    "    else:\n",
    "        chem_gene_homo_mouse_ppi_exp_significant_modules_peripheric[k]=v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4254\n",
      "1159\n",
      "5091\n",
      "833\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "chem_gene_homo_mouse_no_central_no_module = []\n",
    "\n",
    "for chem in chem_gene_homo_mouse_ppi.keys():\n",
    "    if chem not in chem_gene_homo_mouse_ppi_exp_significant_modules.keys() and chem not in chem_gene_homo_mouse_ppi_hub_exposures.keys():\n",
    "        chem_gene_homo_mouse_no_central_no_module.append(chem)\n",
    "\n",
    "\n",
    "print(len(chem_gene_homo_mouse_no_central_no_module))\n",
    "print(len(chem_gene_homo_mouse_ppi_hub_exposures))\n",
    "print(len(chem_gene_homo_mouse_ppi_exp_significant_modules_central))\n",
    "print(len(chem_gene_homo_mouse_ppi_exp_significant_modules_peripheric))\n",
    "\n",
    "print(len(chem_gene_homo_mouse_no_central_no_module)+len(chem_gene_homo_mouse_ppi_hub_exposures)+len(chem_gene_homo_mouse_ppi_exp_significant_modules_central)+len(chem_gene_homo_mouse_ppi_exp_significant_modules_peripheric)==len(chem_gene_homo_mouse_ppi))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x2000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Here, we show the proportion of the chemical classes in the entire CTD \n",
    "fig, ax = plt.subplots(figsize=(10, 20), subplot_kw=dict(aspect=\"equal\"))\n",
    "radius = 1\n",
    "\n",
    "cmap = plt.cm.viridis\n",
    "\n",
    "\n",
    "sizes=[len(chem_gene_homo_mouse_ppi_hub_exposures),len(chem_gene_homo_mouse_ppi_exp_significant_modules_central),len(chem_gene_homo_mouse_ppi_exp_significant_modules_peripheric),len(chem_gene_homo_mouse_no_central_no_module)]\n",
    "\n",
    "wedges, texts = ax.pie(sizes, wedgeprops=dict(width=1), startangle=-125)\n",
    "\n",
    "bbox_props = dict(boxstyle=\"square,pad=0.2\", fc=\"w\", ec=\"k\", lw=1.72)\n",
    "kw = dict(arrowprops=dict(arrowstyle=\"-\"),\n",
    "          bbox=bbox_props, zorder=0, va=\"center\")\n",
    "\n",
    "#for i, p in enumerate(wedges):\n",
    "#    ang = (p.theta2 - p.theta1)/2. + p.theta1\n",
    "#    y = np.sin(np.deg2rad(ang))\n",
    "#    x = np.cos(np.deg2rad(ang))\n",
    "#    horizontalalignment = {-1: \"right\", 1: \"left\"}[int(np.sign(x))]\n",
    "#    connectionstyle = \"angle,angleA=0,angleB={}\".format(ang)\n",
    "#    kw[\"arrowprops\"].update({\"connectionstyle\": connectionstyle})\n",
    "#    ax.annotate(labels[i], xy=(x, y), xytext=(1.8*np.sign(x), 2.5*y),\n",
    "#                horizontalalignment=horizontalalignment,fontsize=24, **kw)\n",
    "plt.savefig('output/Figures/SF7B_v01_post_rev.pdf',format='pdf',dpi=300, bbox_inches = \"tight\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "lcc_zscore_2_df=pd.DataFrame()\n",
    "\n",
    "category_list=[]\n",
    "zscore_list=[]\n",
    "for z in [v for v in final_exposome_zscore.values() if str(v)!='nan' and str(v)!='inf']:\n",
    "    zscore_list.append(z)\n",
    "    category_list.append(\"all exposures\")\n",
    " \n",
    "for z in [v for v in final_chem_gene_homo_mouse_ppi_zscore.values() if str(v)!='nan' and str(v)!='inf']:\n",
    "    zscore_list.append(z)\n",
    "    category_list.append(\"Homo-Mouse\")\n",
    "\n",
    "for z in [v for v in final_chem_gene_hq_ppi_zscore.values() if str(v)!='nan' and str(v)!='inf']:\n",
    "    zscore_list.append(z)\n",
    "    category_list.append(\"Homo HQ\")   \n",
    "\n",
    "lcc_zscore_2_df['group']=category_list\n",
    "lcc_zscore_2_df['z-score']=zscore_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from joypy import joyplot\n",
    "import seaborn as sns\n",
    "\n",
    "joyplot(lcc_zscore_2_df, by='group', kind = \"normalized_counts\",column='z-score',colormap=sns.color_palette(\"crest\", as_cmap=True));\n",
    "\n",
    "plt.xlabel('z-score');\n",
    "plt.vlines(x=2,ymin=0,ymax=1,color='r',label='statistically significance',zorder=10);\n",
    "plt.savefig('output/Figures/SF7C_v01_post_rev.pdf',format='pdf',dpi=300, bbox_inches = \"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/HomoMouse_No_central_no_module_exposures.txt', 'w')\n",
    "\n",
    "for exp in chem_gene_homo_mouse_no_central_no_module:\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/HomoMouse_Hub_exposures.txt', 'w')\n",
    "\n",
    "for exp in list(chem_gene_homo_mouse_ppi_hub_exposures.keys()):\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/HomoMouse_Central_module_exposures.txt', 'w')\n",
    "\n",
    "for exp in list(chem_gene_homo_mouse_ppi_exp_significant_modules_central.keys()):\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = open('output/HomoMouse_Peripheric_module_exposures.txt', 'w')\n",
    "\n",
    "for exp in list(chem_gene_homo_mouse_ppi_exp_significant_modules_peripheric.keys()):\n",
    "    output_file.write(exp + '\\n')\n",
    "\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}