variant_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d7d3b7ef-a8d8-450e-9901-4deb61dcb045",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from glob import glob\n",
    "import ahocorasick\n",
    "import os\n",
    "import sys\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "89436559-80ca-47bd-bfe7-fdedaa8f2b64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4991\n",
      "4991\n",
      "97\n"
     ]
    }
   ],
   "source": [
    "def get_info(files, key_col = '', value_col = ''):\n",
    "    key_values = {}\n",
    "    value_keys = {}\n",
    "    for f in files:\n",
    "        \n",
    "        lines = [x.strip().split('\\t') for x in open(f, 'r').readlines()]\n",
    "        key_col_n = 0\n",
    "        value_col_n = 1\n",
    "        if key_col != '':\n",
    "            key_col_n = lines[0].index(key_col)\n",
    "            value_col_n = lines[0].index(value_col)\n",
    "        \n",
    "        for line in lines[1::]:\n",
    "            key = line[key_col_n]\n",
    "            values  = line[value_col_n]\n",
    "            \n",
    "            for value in values.split(','):\n",
    "                try:\n",
    "                    value_keys[value].add(key)\n",
    "                except KeyError:\n",
    "                    value_keys[value] = set([key])\n",
    "                \n",
    "                try:\n",
    "                    key_values[key].add(value)\n",
    "                except KeyError:\n",
    "                    key_values[key] = set([value])\n",
    "\n",
    "    return value_keys, key_values\n",
    "\n",
    "peps_tissues, tissues_peps = get_info(['count-tables/PXD016999-tissue_peps.tsv', 'count-tables/PXD010154-tissue_peps.tsv'])\n",
    "peps_samples, samples_peps = get_info(['count-tables/sample_peps.tsv'])\n",
    "\n",
    "population_samples, sample_populations = get_info(['samples_metadata.tsv'], key_col='Accession', value_col = 'Population')\n",
    "\n",
    "print(len(peps_samples))\n",
    "print(len(peps_tissues))\n",
    "print(len(sample_populations))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3ce6048a-f906-4586-ab7e-126c373719e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'African', 'Asian', 'Caucasian', 'South-American', 'South-Asian', 'T2T'}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population_groups = {\n",
    "    'African Ancestry From Barbados In The Caribbean' : 'African', \n",
    "    'African Caribbean In Barbados' : 'African',\n",
    "    'Asian' : 'Asian',\n",
    "    'Barbados' : 'South-American',\n",
    "    'Caucasian' : 'Caucasian',\n",
    "    'Colombian In Medellin - Colombia' : 'South-American',\n",
    "    'Esan In Nigeria' : 'African',\n",
    "    'Gambian In Western Division - The Gambia' : 'African',\n",
    "    'Gambian In Western Division Of Gambia' : 'African',\n",
    "    'Han Chinese South' : 'Asian',\n",
    "    'Kinyawa - Kenya' : 'African',\n",
    "    'Mende In Sierra Leone' : 'African',\n",
    "    'Mende Of Sierra Leone' : 'African',\n",
    "    'Peruvian In Lima - Peru' : 'South-American',\n",
    "    'Puerto Rican In Puerto Rico' : 'South-American',\n",
    "    'Puerto Rico' : 'South-American',\n",
    "    'Punjabi In Lahore - Pakistan' : 'South-Asian',\n",
    "    'Southwest USA' : 'Caucasian',\n",
    "    'T2T' : 'T2T',\n",
    "    'Vietnamese Kinh In Ho Chi Minh City - Vietnam' : 'Asian',\n",
    "    'Yoruban' : 'African',\n",
    "    'Yoruban In Ibadan - Nigeria' : 'African'\n",
    "}\n",
    "set(population_groups.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cf2e116f-af89-45e0-8abe-f6e1ea0cbd9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'T2T': 1,\n",
       " 'African': 44,\n",
       " 'South-American': 34,\n",
       " 'Asian': 10,\n",
       " 'Caucasian': 6,\n",
       " 'South-Asian': 2}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_samples_per_population_group = {}\n",
    "for p in population_samples:\n",
    "    pg = population_groups[p]\n",
    "    try:\n",
    "        num_samples_per_population_group[pg]+=len(set(population_samples[p]))\n",
    "    except KeyError:\n",
    "        num_samples_per_population_group[pg]=len(set(population_samples[p]))\n",
    "num_samples_per_population_group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4e583f2a-bd4c-4fcf-bc91-526c41cef195",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4766\n"
     ]
    }
   ],
   "source": [
    "peps_file = 'blast_canonical-count-tables/1-2mismatches_peptides_match_info/peptide_gene_symbol_protein_matching_info_add.tsv'\n",
    "peps_header = [x.strip().split('\\t') for x in open(peps_file, 'r').readlines()][0]\n",
    "peps_all = [x.strip().split('\\t') for x in open(peps_file, 'r').readlines()][1::]\n",
    "\n",
    "pep_var_info = {}\n",
    "for i, pep_line in enumerate(peps_all):\n",
    "    pep_seq = pep_line[peps_header.index('peptide')]\n",
    "    prot_id = pep_line[peps_header.index('canonical_protein_ID')]\n",
    "    prot_seq = pep_line[peps_header.index('canonical_protein_seq')]\n",
    "    \n",
    "    gene_symbol = pep_line[peps_header.index('gene_symbol')]\n",
    "    \n",
    "    variant_info = pep_line[peps_header.index('mismatch_info')]\n",
    "    var = re.sub('[0-9]+', '', variant_info) \n",
    "    var_pos = re.sub('[A-Z]', '', variant_info).split('>')[0].split('-')[0]\n",
    "    \n",
    "    #to differentiate between same variants at different locations of the protein add an additional AA.\n",
    "    try:\n",
    "        var = prot_seq[int(var_pos)-2] + '#' + var + '#' + prot_seq[int(var_pos)] \n",
    "    except IndexError:\n",
    "        pass\n",
    "\n",
    "    samples = pep_line[peps_header.index('GCA_protein_seq')].split('[')[3].split(']')[0].replace(\" \", \"\").replace(\"'\", \"\").split(\",\")\n",
    "    tissues = set()\n",
    "    try:\n",
    "        tissues = set(peps_tissues[pep_seq])\n",
    "    except KeyError:\n",
    "        pass\n",
    "    \n",
    "    try:\n",
    "        pep_var_info[pep_seq][0].append(var)\n",
    "        pep_var_info[pep_seq][1].append(variant_info)\n",
    "        pep_var_info[pep_seq][2].union(samples)\n",
    "        pep_var_info[pep_seq][3].union(tissues)\n",
    "        pep_var_info[pep_seq][3].union(prot_id.split(','))\n",
    "        pep_var_info[pep_seq][3].union(set(gene_symbol.split(',')))\n",
    "    except KeyError:\n",
    "        pep_var_info[pep_seq] = [[var], [variant_info], set(samples), set(tissues), set(prot_id.split(',')), set(gene_symbol.split(','))]\n",
    "print(len(pep_var_info))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e5f105d2-d7bc-41cd-86b8-181daf22bcbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3780\n"
     ]
    }
   ],
   "source": [
    "#identify peptides that are substrings of each other\n",
    "pep_var_info_sorted = {}\n",
    "for k in sorted(pep_var_info, key=len, reverse=True):\n",
    "    pep_var_info_sorted[k] = pep_var_info[k]\n",
    "\n",
    "inserted_pairs = {}\n",
    "matching_peps = {}\n",
    "for pep_seq in pep_var_info_sorted.keys():\n",
    "    p1 = pep_seq\n",
    "    for s in matching_peps.keys():\n",
    "        if pep_seq in s:# and pep_var_info_sorted[pep_seq][0]==pep_var_info_sorted[s][0]:\n",
    "            p1 = s\n",
    "            break\n",
    "    \n",
    "    if p1==pep_seq:\n",
    "        for pep in pep_var_info_sorted.keys():\n",
    "            if ((pep_seq in pep) and pep_var_info_sorted[pep_seq][0]==pep_var_info_sorted[pep][0]):\n",
    "                p1 = pep\n",
    "                break\n",
    "    \n",
    "    try:\n",
    "        matching_peps[p1].append(pep_seq)\n",
    "    except KeyError:\n",
    "        matching_peps[p1] = [pep_seq]\n",
    "\n",
    "print(len(matching_peps))\n",
    "#print(matching_peps)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "85129d3a-8c64-4784-8005-5a218ed2306d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3780\n"
     ]
    }
   ],
   "source": [
    "#Merge peptides with their overlapping ones (missed cleavage)\n",
    "matching_peps_merged = {}\n",
    "for pep_key, peps in matching_peps.items(): \n",
    "    \n",
    "    for p in matching_peps.keys():\n",
    "        if p == pep_key or pep_key in matching_peps_merged.values():\n",
    "            continue\n",
    "        if ( pep_var_info_sorted[p][0] == pep_var_info_sorted[pep_key][0] and\n",
    "            (set(pep_var_info_sorted[p][1]).issubset(set(pep_var_info_sorted[pep_key][1])) or \n",
    "            set(pep_var_info_sorted[pep_key][1]).issubset(set(pep_var_info_sorted[p][1]))) and\n",
    "            pep_var_info_sorted[p][-1] == pep_var_info_sorted[pep_key][-1] ):\n",
    "            if len(set(pep_key).intersection(set(p)))>3:\n",
    "                try:\n",
    "                    matching_peps_merged[pep_key].extend(matching_peps[p])\n",
    "                except KeyError:\n",
    "                    matching_peps_merged[pep_key]= matching_peps[pep_key][0::]\n",
    "                    matching_peps_merged[pep_key].extend(matching_peps[p])\n",
    "\n",
    "for pep_key in matching_peps.keys():\n",
    "    keys = matching_peps_merged.keys()\n",
    "    items = matching_peps_merged.values()\n",
    "    \n",
    "    if pep_key not in items and pep_key not in keys:\n",
    "        matching_peps_merged[pep_key] = matching_peps[pep_key]\n",
    "\n",
    "print(len(matching_peps_merged))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a33c6779-2b95-4442-a6e9-f3cca2b2b599",
   "metadata": {},
   "outputs": [],
   "source": [
    "samples_var_dict = {} \n",
    "genes_var_dict = {}\n",
    "tissues_var_dict = {}\n",
    "items_added = []\n",
    "header = []\n",
    "with open('blast_canonical-count-tables/1-2mismatches_peptides_match_info/peps_merged_vars.tsv', 'w') as out, open('blast_canonical-count-tables/1-2mismatches_peptides_match_info/peps_merged_populations.tsv', 'w') as out2:\n",
    "    out.write('{}\\n'.format('\\t'.join(\n",
    "        'Peptide,num_unique_peptides,num_tissues,num_samples,num_populations,population_groups,populations,variants,genes,overlapping_peptides,tissues,samples'.split(','))))\n",
    "\n",
    "    out2.write('{}\\n'.format('\\t'.join('peptide,genes,variants,population_groups,populations'.split(','))))\n",
    "    for pep_key, peps in matching_peps_merged.items():\n",
    "        peps_u = set(sorted(peps))\n",
    "        if peps_u in items_added:\n",
    "            continue\n",
    "        \n",
    "        items_added.append(peps_u)\n",
    "        \n",
    "        var = []\n",
    "        for v in pep_var_info_sorted[pep_key][0]:\n",
    "            var.extend(v.split(','))\n",
    "\n",
    "        genes = []\n",
    "        tissues = []\n",
    "        samples = []\n",
    "        for pep in peps_u:\n",
    "            samples.extend(pep_var_info_sorted[pep][2])\n",
    "            tissues.extend(pep_var_info_sorted[pep][3])\n",
    "            genes.extend(pep_var_info_sorted[pep][-1])\n",
    "            \n",
    "\n",
    "        var_uniq = [] #','.join(set(var))\n",
    "        for v in set(var):\n",
    "            try:\n",
    "                var_uniq.append(v.split('#')[1])\n",
    "            except IndexError:\n",
    "                var_uniq.append(v)\n",
    "\n",
    "        populations = []\n",
    "        populations_group_this = []\n",
    "        for ss in samples[::]:\n",
    "            populations.extend(list(sample_populations[ss]))\n",
    "            populations_group_this.extend([population_groups[x] for x in list(sample_populations[ss])])\n",
    "\n",
    "        out.write('{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\n'.format(pep_key, len(peps_u), len(set(tissues)), \n",
    "                                                            len(set(samples)), len(set(populations)),\n",
    "                                                            ','.join(set(populations_group_this)),\n",
    "                                                            ','.join(set(populations)), \n",
    "                                                            ','.join(var_uniq), \n",
    "                                                            ','.join(set(genes)), ','.join(peps_u), \n",
    "                                                            ','.join(set(tissues)), ','.join(set(samples))))\n",
    "        for p in set(populations):\n",
    "            out2.write('{}\\t{}\\t{}\\t{}\\t{}\\n'.format(pep_key, ','.join(set(genes)), ','.join(var_uniq), population_groups[p], p))\n",
    "\n",
    "        for s in set(samples):\n",
    "            try:\n",
    "                samples_var_dict[s][0].extend(var[::])\n",
    "                samples_var_dict[s][1].extend(list(peps_u))\n",
    "            except KeyError:\n",
    "                samples_var_dict[s] = [var[::], list(peps_u)]\n",
    "\n",
    "        for t in set(tissues):\n",
    "            try:\n",
    "                tissues_var_dict[t][0].extend(var[::])\n",
    "                tissues_var_dict[t][1].extend(list(peps_u))\n",
    "            except KeyError:\n",
    "                tissues_var_dict[t] = [var[::], list(peps_u)]\n",
    "        \n",
    "        for g in set(genes):\n",
    "            try:\n",
    "                genes_var_dict[g][0].extend(var[::])\n",
    "                genes_var_dict[g][1].extend(list(peps_u))\n",
    "                genes_var_dict[g][2].extend(tissues[::])\n",
    "                genes_var_dict[g][3].extend(samples[::])\n",
    "                \n",
    "            except KeyError:\n",
    "                genes_var_dict[g] = [var[::], list(peps_u), tissues[::], samples[::]]\n",
    "\n",
    "#print(\"variants and peptides associated to AKAP12 gene\\n\", ','.join([x.split('#')[1] for x in set(genes_var_dict['AKAP12'][0])]), '\\n', set(genes_var_dict['AKAP12'][1]))\n",
    "\n",
    "#make a sample file, number of variants per sample\n",
    "with open('blast_canonical-count-tables/1-2mismatches_peptides_match_info/samples_merged_pep_vars.tsv', 'w') as outs:\n",
    "    outs.write('{}\\n'.format('\\t'.join('sample,num_vars,num_peptides,population_groups,populations,variants,peptides,'.split(','))))\n",
    "    for s, i in samples_var_dict.items():\n",
    "        var_uniq = []\n",
    "        for v in set(i[0]):\n",
    "            try:\n",
    "                var_uniq.append(v.split('#')[1])\n",
    "            except IndexError:\n",
    "                var_uniq.append(v)\n",
    "        population = sample_populations[s]\n",
    "        outs.write('{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t\\n'.format(s, len(set(i[0])), len(set(i[1])), ','.join([population_groups[x] for x in population]), ','.join(population), ','.join(var_uniq), ','.join(set(i[1])) ))\n",
    "\n",
    "#make a gene file, number of variants per gene, supprted by #PSMs and peptides\n",
    "with open('blast_canonical-count-tables/1-2mismatches_peptides_match_info/genes_merged_pep_vars.tsv', 'w') as outg:\n",
    "    outg.write('{}\\n'.format('\\t'.join(\n",
    "        'gene,num_vars,num_peptides,num_tissues,num_samples,num_populations,population_groups,populations,variants,peptides,tissues,samples'.split(','))))\n",
    "    for g, i in genes_var_dict.items():\n",
    "        var_uniq = []\n",
    "        for v in set(i[0]):\n",
    "            try:\n",
    "                var_uniq.append(v.split('#')[1])\n",
    "            except IndexError:\n",
    "                var_uniq.append(v)\n",
    "\n",
    "        populations = []\n",
    "        populations_group_this = []\n",
    "        for s in set(i[3]):\n",
    "            populations.extend(list(sample_populations[s]))\n",
    "            populations_group_this.extend([population_groups[x] for x in list(sample_populations[s])])\n",
    "            \n",
    "        outg.write('{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\t{}\\n'.format(\n",
    "                                                                g, len(var_uniq), \n",
    "                                                                len(set(i[1])), len(set(i[2])), len(set(i[3])),  \n",
    "                                                                len(set(populations)), \n",
    "                                                                ','.join(set(populations_group_this)),\n",
    "                                                                ','.join(set(populations)),\n",
    "                                                                 ','.join(var_uniq), #vars\n",
    "                                                                 ','.join(set(i[1])), #peps\n",
    "                                                                 ','.join(set(i[2])), #tissues\n",
    "                                                                 ','.join(set(i[3])) )) #samples\n",
    "\n",
    "#make a tissue file, number of variatns and number of gene variants per tissue\n",
    "with open('blast_canonical-count-tables/1-2mismatches_peptides_match_info/tissues_merged_pep_vars.tsv', 'w') as outt:\n",
    "    outt.write('{}\\n'.format('\\t'.join('tissue,num_vars,num_peptides,variants,peptides,'.split(','))))\n",
    "    for t, i in tissues_var_dict.items():\n",
    "        var_uniq = []\n",
    "        for v in set(i[0]):\n",
    "            try:\n",
    "                var_uniq.append(v.split('#')[1])\n",
    "            except IndexError:\n",
    "                var_uniq.append(v)\n",
    "        \n",
    "        outt.write('{}\\t{}\\t{}\\t{}\\t{}\\n'.format(t, len(set(i[0])), len(set(i[1])), \n",
    "                                                 ','.join(var_uniq), \n",
    "                                                 ','.join(set(i[1])) ))\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9b6d1c69-a842-475f-b5d5-5876a1cd59ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['gene', 'num_vars', 'num_peptides', 'num_tissues', 'num_samples',\n",
       "       'num_populations', 'population_groups', 'populations', 'variants',\n",
       "       'peptides', 'tissues', 'samples'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "genes_df = pd.read_csv('blast_canonical-count-tables/1-2mismatches_peptides_match_info/genes_merged_pep_vars.tsv', sep='\\t')\n",
    "genes_df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f34ecc37-2e28-4f5f-a2b9-42aeb6a38144",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# use the scatterplot function to build the bubble map\n",
    "\n",
    "genes_df_filtered = genes_df[(genes_df.num_vars>5)]\n",
    "plt.figure(figsize=(5, 5))\n",
    "custom_params = {\"axes.spines.right\": False, \"axes.spines.top\": False}\n",
    "sns.set_theme(style=\"ticks\", rc=custom_params)\n",
    "plot = sns.scatterplot(\n",
    "    data=genes_df_filtered,\n",
    "    x=\"num_vars\",\n",
    "    y=\"num_peptides\",\n",
    "    size=\"num_samples\",\n",
    "    legend=True,\n",
    "    sizes=(5, 400)\n",
    ")\n",
    "for i,g in enumerate(genes_df_filtered.gene.tolist()):\n",
    "    plot.annotate(g, (genes_df_filtered.num_vars.tolist()[i], genes_df_filtered.num_peptides.tolist()[i]))\n",
    "plt.title('Genes with more than 5 variants')\n",
    "plt.xlabel('Number of Variants')\n",
    "# Set y-axis label\n",
    "plt.ylabel('Number of peptides')\n",
    "# plt.tight_layout()\n",
    "\n",
    "sns.despine()\n",
    "plt.savefig('genes_num_vars_peps_samples.svg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b0ec8de3-35bf-4263-9b74-0333acc1a486",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "plt.figure(figsize=(7, 7))\n",
    "custom_params = {\"axes.spines.right\": False, \"axes.spines.top\": False}\n",
    "sns.set_theme(style=\"ticks\", rc=custom_params)\n",
    "plot = sns.histplot(genes_df[\"num_vars\"].astype(float), binwidth=1) \n",
    "plt.title('Distributions of number of variants per gene')\n",
    "plt.xlabel('Number of Variants')\n",
    "    # Set y-axis label\n",
    "plt.ylabel('Number of genes')\n",
    "# plt.tight_layout()\n",
    "\n",
    "\n",
    "plt.savefig('dist_genes_num_vars.svg', format='svg', transparent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c69c8ed2-ae37-47b4-9c4e-e9c22c0eccae",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Load your data into a pandas DataFrame\n",
    "data = genes_df\n",
    "\n",
    "# Define thresholds for classification\n",
    "variant_threshold = data['num_vars'].quantile(0.75)\n",
    "peptide_threshold = data['num_peptides'].quantile(0.75)\n",
    "sample_threshold = data['num_samples'].quantile(0.75)\n",
    "\n",
    "# Classify genes based on thresholds\n",
    "data['highly_modified'] = data['num_vars'] > variant_threshold\n",
    "data['highly_identified'] = data['num_peptides'] > peptide_threshold\n",
    "data['highly_prevalent'] = data['num_samples'] > sample_threshold\n",
    "data.to_csv('blast_canonical-count-tables/1-2mismatches_peptides_match_info/updated_pepts_with_classifications.tsv', index=False, sep=\"\\t\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ad05f938-6336-4dde-8088-2c69bab61d0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Show number of peptides per population:  Puerto Rican In Puerto Rico                        2095\n",
      "Gambian In Western Division - The Gambia           1902\n",
      "Colombian In Medellin - Colombia                   1744\n",
      "African Caribbean In Barbados                      1655\n",
      "Peruvian In Lima - Peru                            1463\n",
      "Mende In Sierra Leone                              1407\n",
      "Han Chinese South                                  1336\n",
      "African Ancestry From Barbados In The Caribbean    1231\n",
      "Caucasian                                          1001\n",
      "Puerto Rico                                         987\n",
      "Punjabi In Lahore - Pakistan                        953\n",
      "Asian                                               926\n",
      "Kinyawa - Kenya                                     920\n",
      "Yoruban In Ibadan - Nigeria                         900\n",
      "Barbados                                            899\n",
      "Southwest USA                                       898\n",
      "Mende Of Sierra Leone                               892\n",
      "Vietnamese Kinh In Ho Chi Minh City - Vietnam       891\n",
      "Esan In Nigeria                                     889\n",
      "Yoruban                                             864\n",
      "Gambian In Western Division Of Gambia               833\n",
      "T2T                                                 689\n",
      "Name: populations, dtype: int64\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "peps_pops_df = pd.read_csv('blast_canonical-count-tables/1-2mismatches_peptides_match_info/peps_merged_populations.tsv', sep='\\t')\n",
    "\n",
    "# Venn diagram\n",
    "from matplotlib_venn import venn3\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "pop_stats = peps_pops_df['populations'].value_counts()\n",
    "print('Show number of peptides per population: ', pop_stats)\n",
    "venn3(subsets=list(pop_stats), set_labels = list(pop_stats.index))\n",
    "\n",
    "plt.title('Peptides per Population ')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3f1fbfaf-1992-440d-b79a-46ca8443b639",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Load your data into a pandas DataFrame\n",
    "data = genes_df\n",
    "\n",
    "# Venn diagram\n",
    "from matplotlib_venn import venn3\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "venn3(subsets=(\n",
    "    data['highly_modified'].sum(),\n",
    "    data['highly_identified'].sum(),\n",
    "    data['highly_prevalent'].sum(),\n",
    "    (data['highly_modified'] & data['highly_identified']).sum(),\n",
    "    (data['highly_modified'] & data['highly_prevalent']).sum(),\n",
    "    (data['highly_identified'] & data['highly_prevalent']).sum(),\n",
    "    (data['highly_modified'] & data['highly_identified'] & data['highly_prevalent']).sum()\n",
    "), set_labels=('highly modified', 'highly identified', 'highly prevalent'))\n",
    "plt.title('Genes by Classifications')\n",
    "# Save plot as SVG\n",
    "plt.savefig('venn_diagram_gene_classifications.svg', format='svg', transparent=True)\n",
    "\n",
    "data.to_csv('updated_pepts_with_classifications.tsv', index=False, sep=\"\\t\")\n"
   ]
  }
 ],
 "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}