Identification of connected genes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### import libraries\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import openpyxl as opx\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.spatial.distance import pdist, squareform"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### input variables\n",
    "\n",
    "mainPath = '' # path to all files\n",
    "\n",
    "allLocusTagsFilename = '' # file name (excel) of the locus tags to be checked\n",
    "sheetName = '' # sheet name if exist; optional parameter\n",
    "diffExprColName = '' # name of the column with information about the sign of differential expression\n",
    "\n",
    "cytokin = '' # name of cytokin; 'TNF' and 'IL6' were used in this work\n",
    "\n",
    "orthogroupsFilename = '' # name of the table with orthogroups from the Orthofinder outputs; for example, 'Orthogroups.tsv'\n",
    "orthogroupsGeneCountFilename = '' # name of the table with gene counts from the Orthofinder outputs; for example, 'Orthogroups.GeneCount.tsv'\n",
    "organismName = '' # name of the analysed organism which is the same as in the tables from the Orthofinder outputs; for example, 'GCF_000772485.1_ASM77248v1_translated_cds'\n",
    "organismFaaFilename = '' # file name (fasta; translated cds) of the organism to be analysed\n",
    "\n",
    "minimalOGdist = 0.01 # the minimum value of the threshold for recognition of 'neighboring' orthogroups\n",
    "genomeDist = 10000 # the minimum distance in genome of the analysed organism for searching connected genes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### opening file with locus tags to be checked\n",
    "\n",
    "if sheetName != '':\n",
    "    allLocusTags_df = pd.read_excel(io = mainPath + allLocusTagsFilename, sheet_name=sheetName)\n",
    "else:\n",
    "    allLocusTags_df = pd.read_excel(io = mainPath + allLocusTagsFilename)\n",
    "\n",
    "# checking\n",
    "allLocusTags_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### opening file (fasta; translated cds) of the organism to be analysed\n",
    "\n",
    "file = open(mainPath + organismFaaFilename, 'r')\n",
    "organismFaaFile = file.read()\n",
    "file.close()\n",
    "\n",
    "# checking\n",
    "organismFaaFile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### function for finding WP-number, location and sign of strain of protein in organismFaaFile using locus \n",
    "### tags from allLocusTags_df\n",
    "\n",
    "def get_WP_and_location(tag, text):\n",
    "    \n",
    "    tag_str_index = text.find('locus_tag' + '=' + tag)\n",
    "    \n",
    "    if tag_str_index == -1:\n",
    "        WP, loc, strain = '', '', ''\n",
    "\n",
    "    else:\n",
    "        str_with_WP_and_loc = text[tag_str_index - 40:tag_str_index + 400]\n",
    "        WP_str_index = str_with_WP_and_loc.find('_prot_')\n",
    "        WP = str_with_WP_and_loc[WP_str_index + 1 : WP_str_index + 20]\n",
    "        if WP[6:10] != 'WP_':\n",
    "            WP = WP.split(' ')[0]  \n",
    "        loc_str_index = str_with_WP_and_loc.find('[location=')\n",
    "        loc_str_index_end = str_with_WP_and_loc.find('] [gbkey=')\n",
    "        loc = str_with_WP_and_loc[loc_str_index + 10 : loc_str_index_end]\n",
    "        if loc[:3] == 'com':\n",
    "            strain = '-'\n",
    "        else:\n",
    "            strain = '+'\n",
    "    \n",
    "    return(WP, loc, strain)\n",
    "\n",
    "# checking\n",
    "get_WP_and_location('BLGT_RS00065', organismFaaFile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### function for creating data frame from dictionary with locus tags from primary file and received WP, \n",
    "### location and sign of strain using function get_WP_and_location\n",
    "\n",
    "def create_tags_WP_df(tags_lst, text):\n",
    "    \n",
    "    WP_lst, loc_lst, strain_lst = [], [], []\n",
    "    \n",
    "    for tag in tags_lst:\n",
    "        tmp = get_WP_and_location(tag, text)\n",
    "        WP_lst.append(tmp[0])\n",
    "        loc_lst.append(tmp[1])\n",
    "        strain_lst.append(tmp[2])\n",
    "        \n",
    "    tags_WP_dic = { 'locus_tag': tags_lst, 'protein': WP_lst, 'location': loc_lst, 'strain': strain_lst }\n",
    "    \n",
    "    return pd.DataFrame.from_dict(tags_WP_dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### creating data frame tagsProtein_df using function create_tags_WP_df and adding to this data frame \n",
    "### data with information about differential expression\n",
    "\n",
    "allLocusTags_lst = allLocusTags_df.locus_tag.tolist()\n",
    "tagsProtein_df = create_tags_WP_df(allLocusTags_lst, organismFaaFile)\n",
    "tagsProtein_df = tagsProtein_df.merge(allLocusTags_df[['locus_tag', diffExprColName]], how='inner')\n",
    "\n",
    "# checking\n",
    "tagsProtein_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### opening file with orthogroups (OG) and WPs from Orthofinder's outputs\n",
    "\n",
    "orthogroups_df = pd.read_csv(mainPath + orthogroupsFilename, sep='\\t', encoding='UTF-8')\n",
    "orthogroups_df = orthogroups_df.replace(np.nan, '', regex=True)\n",
    "\n",
    "# checking\n",
    "orthogroups_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### creating function getting respective orthogroups  \n",
    "\n",
    "def get_OG(orthogroups_df, organism_name, tagsWP_df):\n",
    "    \n",
    "    col = organism_name\n",
    "    WP_lst, OG_ind_lst, OG_lst = [], [], []\n",
    "    \n",
    "    for sub in tagsWP_df.protein.to_list():\n",
    "        \n",
    "        if sub != '':\n",
    "            \n",
    "            found = pd.DataFrame()\n",
    "            found[col] = orthogroups_df[col].str.contains(sub, regex=False)\n",
    "            found_subset = found[col].loc[found[col] > 0]\n",
    "            \n",
    "            if not (found_subset.empty):\n",
    "                \n",
    "                WP_lst.append(sub)\n",
    "                ind = found_subset.index[0]\n",
    "                OG_ind_lst.append(ind)\n",
    "                OG_lst.append(str(orthogroups_df.iloc[ind, 0]))\n",
    "                \n",
    "    WP_OG = pd.DataFrame.from_dict({ 'protein': WP_lst, 'OG_index': OG_ind_lst, 'OG': OG_lst })\n",
    "    \n",
    "    return(WP_OG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### inner joining of the tagsProteinOG_df and tagsProtein_df data frames by \"WP\" key\n",
    "\n",
    "tagsProteinOG_df = get_OG(orthogroups_df, organismName, tagsProtein_df)\n",
    "tagsProtein_df = tagsProtein_df.merge(tagsProteinOG_df, how='inner')\n",
    "\n",
    "# checking\n",
    "tagsProtein_df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### creating data frame with orthogroups and gene counts from Orthofinder's outputs and removing 'Total' \n",
    "### column from gene_count data frame\n",
    "\n",
    "geneCount_df = pd.read_csv(mainPath + orthogroupsGeneCountFilename, sep='\\t', encoding='UTF-8')\n",
    "geneCount_df.drop(['Total'], axis=1, inplace=True)\n",
    "\n",
    "# checking\n",
    "geneCount_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### converting strings to numeric and binary vectors\n",
    "\n",
    "for i in range(1, len(geneCount_df.iloc[0, :])):\n",
    "    pd.to_numeric(geneCount_df.iloc[:, i])\n",
    "\n",
    "col_names = geneCount_df.columns.to_list()[1:]\n",
    "for col in col_names:\n",
    "    geneCount_df.loc[geneCount_df[col] > 0, col] = 1 \n",
    "    \n",
    "# checking \n",
    "geneCount_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### geneCount_df is a data frame of an m by n array of m original observations in an n-dimensional space\n",
    "\n",
    "geneCount_df = geneCount_df.drop(['Orthogroup'], axis=1)\n",
    "\n",
    "# checking\n",
    "geneCount_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### creating jaccard-pdist upper-triangle matrix of distances and converting it to squared matrix of difference\n",
    "\n",
    "distMatrix = np.around(pdist(geneCount_df, 'jaccard'), 3)\n",
    "distMatrix = squareform(distMatrix)\n",
    "\n",
    "# checking\n",
    "distMatrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### changing diaganal values '0' to '1' in distMatrix and creating data frame with distances\n",
    "\n",
    "np.fill_diagonal(distMatrix, 1)\n",
    "distMatrix_df = pd.DataFrame(data=distMatrix)\n",
    "\n",
    "# checking\n",
    "distMatrix_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# checking\n",
    "distMatrix_df.loc[distMatrix_df[9] <= minimalOGdist] #column with number OG_index, where distance <= minimalOGdist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### finding other OG with minimal distances from considered OG* (OG <= minimalOGdist) and creating dictionary,\n",
    "### where considered OG* is a key and found OGs are values\n",
    "\n",
    "def find_min_OG_dist(tagsProtein_df, distMatrix_df, minimalOGdist):\n",
    "    \n",
    "    dict_with_min_distances_OG_to_df = {}\n",
    "    dict_with_min_distances_OG = {}\n",
    "\n",
    "    for OG_index in tagsProtein_df.OG_index.to_list():\n",
    "        \n",
    "        tmp = distMatrix_df.loc[distMatrix_df[OG_index] <= minimalOGdist] #column with number OG_index, where distance <= minimalOGdist\n",
    "        \n",
    "        if not tmp.empty:\n",
    "        \n",
    "            dict_with_min_distances_OG.update({OG_index : tmp.index.to_list()})\n",
    "\n",
    "            dict_with_min_distances_OG_to_df.update({OG_index : ', '.join(map(str, tmp.index.to_list()))})\n",
    "            \n",
    "    return(dict_with_min_distances_OG, dict_with_min_distances_OG_to_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### creating data frame of found OG index with minimal distances\n",
    "\n",
    "minOGDist_dict = find_min_OG_dist(tagsProtein_df, distMatrix_df, minimalOGdist)\n",
    "\n",
    "minOGDist_df = pd.DataFrame(minOGDist_dict[1], index=['found_OG_index_with_min_dist']).T\n",
    "minOGDist_df['OG_index'] = minOGDist_df.index\n",
    "\n",
    "# checking\n",
    "minOGDist_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### left joining of data frames tagsProtein_df and OG_with_min_dist_df by \"OG_index\" key\n",
    "\n",
    "tagsProtein_df = tagsProtein_df.merge(minOGDist_df, on='OG_index', how='left')\n",
    "\n",
    "# checking\n",
    "tagsProtein_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### searching for every found OG with minimal distances from considered OG* (OG <= minimalOGdist) respective WPs\n",
    "\n",
    "foundProtein_dict = {}\n",
    "minOGDist_df_len = len(minOGDist_df)\n",
    "n = 1\n",
    "\n",
    "for key in minOGDist_dict[0].keys():\n",
    "    print('Checking: ' + str(n) + ' OG index out of ' + str(minOGDist_df_len))\n",
    "    for val in minOGDist_dict[0][key]: \n",
    "        lst_tmp = orthogroups_df.loc[val, [organismName]].to_list()\n",
    "        \n",
    "        if lst_tmp != ['']:\n",
    "            foundProtein_dict.update({ val : lst_tmp })\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### creating data frame of found OG indexes with minimal distances and their found WPs (protein)\n",
    "\n",
    "foundProtein_df = pd.DataFrame(foundProtein_dict, index=['found_protein']).T\n",
    "foundProtein_df['OG_index'] = foundProtein_df.index\n",
    "\n",
    "\n",
    "# checking\n",
    "foundProtein_df\n",
    "#foundProtein_df.loc[foundProtein_df['OG_index'] == 5].found_protein.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### division data frame \"found_protein_df\" into separate WP\n",
    "\n",
    "found_protein = foundProtein_df.pop('found_protein').str.split(', ', expand=True)\\\n",
    ".stack().reset_index(1, drop=True).rename('found_protein')\n",
    "\n",
    "foundProtein_df = foundProtein_df.join(found_protein).reset_index(drop=True)\n",
    "\n",
    "# checking\n",
    "foundProtein_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### searching location for every protein (WP) from data frame \"found_protein_df\" in longum_cds.txt\n",
    "\n",
    "loc_lst, strain_lst = [], []\n",
    "prot_lst = foundProtein_df.found_protein.to_list() \n",
    "\n",
    "for prot in prot_lst:\n",
    "    \n",
    "    prot = prot.split()[0]       \n",
    "    prot_str_index = organismFaaFile.find(prot)\n",
    "    \n",
    "    if prot_str_index == -1:\n",
    "        \n",
    "        loc, strain = '', ''\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        str_with_loc = organismFaaFile[prot_str_index:prot_str_index + 400]\n",
    "        loc_str_index = str_with_loc.find('[location=')\n",
    "        loc_str_index_end = str_with_loc.find('] [gbkey=')\n",
    "        loc = str_with_loc[loc_str_index + 10:loc_str_index_end]\n",
    "        \n",
    "        if loc[:3] == 'com':\n",
    "            strain = '-'\n",
    "        else:\n",
    "            strain = '+'\n",
    "        \n",
    "    loc_lst.append(loc)\n",
    "    strain_lst.append(strain)\n",
    "    \n",
    "foundProteinLoc_df = pd.DataFrame({ 'found_protein': prot_lst , 'location': loc_lst, 'strain': strain_lst })\n",
    "\n",
    "# checking\n",
    "foundProteinLoc_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### inner joining of data frames tagsWPdf and OG_with_min_dist_df by \"OG_index\" key\n",
    "\n",
    "foundProteinLoc_df = foundProtein_df.merge(foundProteinLoc_df, on='found_protein', how='inner')\n",
    "\n",
    "# checking\n",
    "foundProteinLoc_df.head(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### division data frame \"found_OG_index_with_min_dist\" into separate OG\n",
    "\n",
    "found_OG_index_with_min_dist = minOGDist_df.pop('found_OG_index_with_min_dist').str.split(',', expand=True)\\\n",
    ".stack().reset_index(1, drop=True).rename('found_OG_index_with_min_dist')\n",
    "\n",
    "minOGDist_df = minOGDist_df.join(found_OG_index_with_min_dist).reset_index(drop=True)\n",
    "\n",
    "# checking\n",
    "minOGDist_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### removing empty values of found_OG_index_with_min_dist column\n",
    "\n",
    "tagsProtein_df.replace(np.nan, '', inplace = True)\n",
    "tagsProtein_df = tagsProtein_df.loc[tagsProtein_df['found_OG_index_with_min_dist'] != '']\n",
    "\n",
    "# checking \n",
    "tagsProtein_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### searching for every initial locus tags found WPs with minimal distances and nearby location (<=genomeDist);\n",
    "### getting all possible suitable WPs\n",
    "\n",
    "locusFoundProtein_dict = {}\n",
    "\n",
    "ind_lst = tagsProtein_df.index\n",
    "n = 1\n",
    "for i in ind_lst:\n",
    "    \n",
    "    print('Checking: ' + str(n) + ' index out of ' + str(len(ind_lst)))\n",
    "    \n",
    "    loc_val = []\n",
    "    #list with found OG_index with minimal distances (OG <= 0.005)\n",
    "    lst_OG = tagsProtein_df.loc[i, ['found_OG_index_with_min_dist']].to_list()[0].split(', ')\n",
    "    \n",
    "    if lst_OG == ['']:\n",
    "        continue\n",
    "        \n",
    "    #initial location \n",
    "    compare_loc = tagsProtein_df.loc[i, ['location']].values[0].split('..')\n",
    "    compare_strain = tagsProtein_df.loc[i, ['strain']].values[0]\n",
    "    \n",
    "    compare_loc_start = compare_loc[0].replace('<', '')\n",
    "    if compare_loc_start[:3] == 'com':\n",
    "        compare_loc_start = compare_loc_start.split('(')[1]\n",
    "\n",
    "    compare_loc_end = compare_loc[1].replace('>', '').replace(')', '')\n",
    "    \n",
    "    dict_loc_val_ind = {}\n",
    "    \n",
    "    for item in lst_OG:\n",
    "        \n",
    "        loc_subset = foundProteinLoc_df.loc[foundProteinLoc_df['OG_index'] == int(item)]\n",
    "        loc_indexes = loc_subset.index\n",
    "        \n",
    "        for k in range(0, len(loc_indexes)):\n",
    "\n",
    "            loc_val = loc_subset.location.values[k].split('..')\n",
    "            if not loc_val:\n",
    "                continue\n",
    "        \n",
    "            loc_val_start = loc_val[0].replace('<', '')\n",
    "            if loc_val_start[:3] == 'com':\n",
    "                loc_val_start = loc_val_start.split('(')[1]\n",
    "    \n",
    "            loc_val_end = loc_val[1].replace('>', '').replace(')', '')\n",
    "                \n",
    "            loc_index = loc_indexes[k]\n",
    "            strain_val = loc_subset.strain.values[k]\n",
    "                    \n",
    "            dict_loc_val_ind.update({ (int(loc_val_start), int(loc_val_end), strain_val) : loc_index })\n",
    "        \n",
    "    lst_found_protein = []\n",
    "    for val, ind in dict_loc_val_ind.items():\n",
    "        \n",
    "        start_cond = int(compare_loc_start) - val[0]\n",
    "        end_cond = val[1] - int(compare_loc_end)\n",
    "        \n",
    "        if (((start_cond > 0 and start_cond <= genomeDist) or (end_cond > 0 and end_cond <= genomeDist)) and (compare_strain == val[2])):\n",
    "            found_protein = foundProteinLoc_df.loc[ind, ['found_protein']].values[0]\n",
    "            lst_found_protein.append(found_protein)\n",
    "        locus_tag = tagsProtein_df.loc[i, ['locus_tag']].values[0]\n",
    "        locusFoundProtein_dict.update({ locus_tag : ', '.join(lst_found_protein) })\n",
    "    \n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# checking\n",
    "locusFoundProtein_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### creating data frame of found OG index with minimal distances\n",
    "\n",
    "locusFoundProtein_df = pd.DataFrame(locusFoundProtein_dict, index=['found_protein']).T\n",
    "locusFoundProtein_df['locus_tag'] = locusFoundProtein_df.index\n",
    "\n",
    "locusFoundProtein_df = locusFoundProtein_df.reset_index(drop=True)\n",
    "locusFoundProtein_df = locusFoundProtein_df.loc[locusFoundProtein_df['found_protein'] != '']\n",
    "\n",
    "cols = locusFoundProtein_df.columns.tolist()\n",
    "cols = cols[-1:] + cols[:-1]\n",
    "locusFoundProtein_df = locusFoundProtein_df[cols]\n",
    "\n",
    "# checking\n",
    "locusFoundProtein_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### merging of the locusFoundProtein_df and tagsProtein_df data frames\n",
    "\n",
    "locusFoundProteinProt_df = locusFoundProtein_df.merge(tagsProtein_df[['locus_tag', 'protein', diffExprColName]], how='inner')\n",
    "\n",
    "# checking \n",
    "locusFoundProteinProt_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### writing results in file.xlsx and file.csv\n",
    "\n",
    "locusFoundProtein_df.to_excel((mainPath + 'Results/' + cytokin + '/' + cytokin + '_locus_found_protein_' + str(minimalOGdist) + '_' + str(genomeDist) + '.xlsx'), index=False)\n",
    "locusFoundProtein_df.to_csv((mainPath + 'Results/' + cytokin + '/' + cytokin + '_locus_found_protein_' + str(minimalOGdist) + '_' + str(genomeDist) + '.csv'), sep='\\t', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### searching initial proteins in found proteins;\n",
    "### identification of connected initial genes and creating graph of these connections\n",
    "\n",
    "G = nx.MultiGraph()\n",
    "index_lst = locusFoundProteinProt_df.index.to_list()\n",
    "\n",
    "for ind in index_lst:\n",
    "    \n",
    "        compareDiffExpr = locusFoundProteinProt_df.loc[ind][diffExprColName]\n",
    "        #if compareDiffExpr == '':  \n",
    "         #   continue\n",
    "        #else:\n",
    "        prot = locusFoundProteinProt_df.loc[ind].protein\n",
    "\n",
    "        \n",
    "        initialTag = locusFoundProteinProt_df.loc[ind].locus_tag\n",
    "        if prot != '':\n",
    "            \n",
    "            bool_lst = locusFoundProtein_df.found_protein.str.contains(prot, regex=False)\n",
    "            found_df = locusFoundProtein_df.loc[bool_lst]\n",
    "            \n",
    "            if not (found_df.empty):\n",
    "                                \n",
    "                tags = found_df.locus_tag.to_list()\n",
    "                \n",
    "                for tag in tags:\n",
    "                    \n",
    "                    diffExpr = locusFoundProteinProt_df.loc[locusFoundProteinProt_df['locus_tag'] == tag][diffExprColName].values[0]\n",
    "                    if diffExpr != '' and compareDiffExpr != '':\n",
    "                        if (compareDiffExpr > 0 and diffExpr > 0) or (compareDiffExpr < 0 and diffExpr < 0):\n",
    "                            G.add_edge(initialTag, tag)\n",
    "                    else:\n",
    "                        G.add_edge(initialTag, tag)               "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### visualisation of the graph and writing results in file.png\n",
    "\n",
    "pos = nx.spiral_layout(G, equidistant=True, scale=3)  \n",
    "options = {\n",
    "    'node_color': 'black',\n",
    "    'edge_color': 'red',\n",
    "    'node_size': 0,\n",
    "    #'linewidths': 0,\n",
    "    'width': 0.5,\n",
    "    'with_labels': True,\n",
    "    'font_size': 10,\n",
    "    #'font_family': 'cursive'\n",
    "}\n",
    "plt.figure(3,figsize=(11, 11), dpi=200) \n",
    "nx.draw(G, pos, **options)\n",
    "\n",
    "plt.savefig(mainPath + 'Results/' + cytokin + '/' + cytokin + '_experimental_partner_for_experimental_tags_' + str(minimalOGdist) + '_' + str(genomeDist) + '.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### converting the graph to data frame\n",
    "\n",
    "partnerTags_df = nx.to_pandas_edgelist(G).drop_duplicates().groupby('source', as_index=False).aggregate(lambda x: ', '.join(x))\n",
    "partnerTags_df.columns = ['initial tag', 'found partner tags']\n",
    "\n",
    "# checking\n",
    "partnerTags_df.head(50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### writing results in file.xlsx and file.csv\n",
    "\n",
    "partnerTags_df.to_excel((mainPath + 'Results/' + cytokin + '/' + cytokin + '_experimental_partner_for_experimental_tags_' + str(minimalOGdist) + '_' + str(genomeDist) + '.xlsx'), index=False)\n",
    "partnerTags_df.to_csv((mainPath + 'Results/' + cytokin + '/' + cytokin + '_experimental_partner_for_experimental_tags_' + str(minimalOGdist) + '_' + str(genomeDist) + '.csv'), sep='\\t', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}