{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8f5d769d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import math\n",
    "from tabulate import tabulate\n",
    "from difflib import SequenceMatcher\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "from collections import defaultdict\n",
    "from itertools import chain, combinations\n",
    "from fpgrowth_py import fpgrowth\n",
    "import time\n",
    "\n",
    "from dna import dna\n",
    "from scov import numpy_image_dict\n",
    "from helper import *\n",
    "import zlib\n",
    "import lzma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "148b7aad",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_file1 = r'./input/China_Seq.txt'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a4a1a484",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_file2=  r'./input/USA_Seq.txt'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7cbd52af",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sequence = pd.DataFrame(columns=[\"line no\",\"sequence ratios\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "95a2008d",
   "metadata": {},
   "outputs": [],
   "source": [
    "count_lines=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "00745df9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>line no</th>\n",
       "      <th>sequence ratios</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [line no, sequence ratios]\n",
       "Index: []"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f5281c63",
   "metadata": {},
   "outputs": [],
   "source": [
    "current_start_time = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "52e23471",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(input_file1) as file1, open(input_file2) as file2:\n",
    "    for lineno, (sequence1, sequence2) in enumerate(zip(file1, file2), 1):\n",
    "        sequence = SequenceMatcher(a=sequence1 , b=sequence2) #comparing both the strings\n",
    "        #print(lineno,\" - \",sequence.ratio())\n",
    "        df_sequence.loc[len(df_sequence.index)] = [lineno,sequence.ratio()]\n",
    "        df_sequence['line no'] = df_sequence['line no'].astype(int)\n",
    "        count_lines+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f814a106",
   "metadata": {},
   "outputs": [],
   "source": [
    "current_end_time = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "38e12b9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Time : 2.6285834312438965\n"
     ]
    }
   ],
   "source": [
    "print(\"Total Time :\",current_end_time-current_start_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a4809151",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sequence_missings = df_sequence[df_sequence['sequence ratios']<1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e0e8ea4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "length_changed_genome = len(df_sequence_missings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "466556ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "perc_missing_values = (length_changed_genome/count_lines)*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5ebf614e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Percentage of changed Genome Sequence  1.31 %\n"
     ]
    }
   ],
   "source": [
    "print(\"Percentage of changed Genome Sequence \",round(perc_missing_values,2),\"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "cc2854eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>line no</th>\n",
       "      <th>sequence ratios</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>121</th>\n",
       "      <td>122</td>\n",
       "      <td>0.985915</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>249</th>\n",
       "      <td>250</td>\n",
       "      <td>0.985915</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>251</th>\n",
       "      <td>252</td>\n",
       "      <td>0.985915</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>254</th>\n",
       "      <td>255</td>\n",
       "      <td>0.985915</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>426</th>\n",
       "      <td>427</td>\n",
       "      <td>0.985915</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>589</th>\n",
       "      <td>590</td>\n",
       "      <td>0.985915</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>601</th>\n",
       "      <td>602</td>\n",
       "      <td>0.985915</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>611</th>\n",
       "      <td>612</td>\n",
       "      <td>0.989474</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     line no  sequence ratios\n",
       "121      122         0.985915\n",
       "249      250         0.985915\n",
       "251      252         0.985915\n",
       "254      255         0.985915\n",
       "426      427         0.985915\n",
       "589      590         0.985915\n",
       "601      602         0.985915\n",
       "611      612         0.989474"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_sequence_missings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "76f8e402",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x2d4708e3580>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sequence_missings['sequence ratios'].plot(kind='bar')\n",
    "\n",
    "plt.ylabel(\"Sequence Ration < 1\")\n",
    "plt.xlabel(\"Index / Sequence number where genomes are missing\")\n",
    "\n",
    "#add custom legend to bar chart\n",
    "plt.legend(['Index of Missing Sequences'], prop={'size': 1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "91e45725",
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence1_All=''\n",
    "sequence2_All=''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a733679d",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(input_file1) as file1:\n",
    "    for lineno in file1:\n",
    "        lineno=lineno.strip('\\n')\n",
    "        sequence1_All+=lineno"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e04490d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(input_file2) as file2:\n",
    "    for lineno in file2:\n",
    "        lineno=lineno.strip('\\n')\n",
    "        sequence2_All+=lineno"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e6cd0cf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def basic_Analysis(DNAseq):\n",
    "    total_base = len(DNAseq)\n",
    "    num_Adenine = DNAseq.count('A')\n",
    "    num_Guanine = DNAseq.count('G')\n",
    "    num_Thymine = DNAseq.count('T')\n",
    "    num_Cytosine = DNAseq.count('C')\n",
    "    \n",
    "    if total_base != num_Adenine + num_Guanine + num_Thymine + num_Cytosine:\n",
    "        print('Something is not right')\n",
    "    else : pass\n",
    "    \n",
    "    A_percent = num_Adenine / total_base\n",
    "    G_percent = num_Guanine / total_base\n",
    "    T_percent = num_Thymine / total_base\n",
    "    C_percent = num_Cytosine / total_base\n",
    "    \n",
    "    #visualization\n",
    "    x = np.arange(4)\n",
    "    bases = ['Adenine', 'Guanine', 'Thymine' ,'Cytosine']\n",
    "    values = [num_Adenine, num_Guanine, num_Thymine, num_Cytosine]\n",
    "    plt.bar(x,values)\n",
    "    plt.xticks(x, bases)\n",
    "    plt.show()\n",
    "    table = [['total base',total_base,'Percentage',str('100%')],\n",
    "             ['Adenine:',num_Adenine, 'Percentage:',str(round(A_percent*100,2))+'%'],\n",
    "            ['Guanine:',num_Guanine, 'Percentage:',str(round(G_percent*100,2))+'%'],\n",
    "             ['Thynime:',num_Thymine, 'Percentage:',str(round(T_percent*100,2))+'%'],\n",
    "             ['Cytosine:',num_Cytosine, 'Percentage:',str(round(C_percent*100,2))+'%']]\n",
    "    print(tabulate(table))\n",
    "    print('GC content:', round((((num_Guanine + num_Cytosine) / total_base)*100),2),'%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b1c5ce22",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------  -----  -----------  ------\n",
      "total base  42483  Percentage   100%\n",
      "Adenine:    12688  Percentage:  29.87%\n",
      "Guanine:     8393  Percentage:  19.76%\n",
      "Thynime:    13709  Percentage:  32.27%\n",
      "Cytosine:    7693  Percentage:  18.11%\n",
      "----------  -----  -----------  ------\n",
      "GC content: 37.86 %\n"
     ]
    }
   ],
   "source": [
    "basic_Analysis(sequence1_All)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ef963c92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------  -----  -----------  ------\n",
      "total base  42483  Percentage   100%\n",
      "Adenine:    12686  Percentage:  29.86%\n",
      "Guanine:     8394  Percentage:  19.76%\n",
      "Thynime:    13713  Percentage:  32.28%\n",
      "Cytosine:    7690  Percentage:  18.1%\n",
      "----------  -----  -----------  ------\n",
      "GC content: 37.86 %\n"
     ]
    }
   ],
   "source": [
    "basic_Analysis(sequence2_All)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d9f07b3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>line no</th>\n",
       "      <th>sequence ratios</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>607</th>\n",
       "      <td>608</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>608</th>\n",
       "      <td>609</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>609</th>\n",
       "      <td>610</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>610</th>\n",
       "      <td>611</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>611</th>\n",
       "      <td>612</td>\n",
       "      <td>0.989474</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>612 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     line no  sequence ratios\n",
       "0          1         1.000000\n",
       "1          2         1.000000\n",
       "2          3         1.000000\n",
       "3          4         1.000000\n",
       "4          5         1.000000\n",
       "..       ...              ...\n",
       "607      608         1.000000\n",
       "608      609         1.000000\n",
       "609      610         1.000000\n",
       "610      611         1.000000\n",
       "611      612         0.989474\n",
       "\n",
       "[612 rows x 2 columns]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f4d0cf89",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Fapriori(itemSetList, minSup, minConf):\n",
    "    C1ItemSet = getItemSetFromList(itemSetList)\n",
    "    # Final result global frequent itemset\n",
    "    globalFreqItemSet = dict()\n",
    "    # Storing global itemset with support count\n",
    "    globalItemSetWithSup = defaultdict(int)\n",
    "\n",
    "    L1ItemSet = getAboveMinSup(\n",
    "        C1ItemSet, itemSetList, minSup, globalItemSetWithSup)\n",
    "    currentLSet = L1ItemSet\n",
    "    k = 2\n",
    "\n",
    "    # Calculating frequent item set\n",
    "    while(currentLSet):\n",
    "        # Storing frequent itemset\n",
    "        globalFreqItemSet[k-1] = currentLSet\n",
    "        # Self-joining Lk\n",
    "        candidateSet = getUnion(currentLSet, k)\n",
    "        # Perform subset testing and remove pruned supersets\n",
    "        candidateSet = pruning(candidateSet, currentLSet, k-1)\n",
    "        # Scanning itemSet for counting support\n",
    "        currentLSet = getAboveMinSup(\n",
    "            candidateSet, itemSetList, minSup, globalItemSetWithSup)\n",
    "        k += 1\n",
    "\n",
    "    rules = FassociationRule(globalFreqItemSet, globalItemSetWithSup, minConf)\n",
    "    rules.sort(key=lambda x: x[2])\n",
    "    return globalFreqItemSet, rules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "a0f39c52",
   "metadata": {},
   "outputs": [],
   "source": [
    "def FaprioriFromFile(fname, minSup, minConf):\n",
    "    C1ItemSet, itemSetList = getFromFile(fname)\n",
    "\n",
    "    # Final result global frequent itemset\n",
    "    globalFreqItemSet = dict()\n",
    "    # Storing global itemset with support count\n",
    "    globalItemSetWithSup = defaultdict(int)\n",
    "\n",
    "    L1ItemSet = getAboveMinSup(\n",
    "        C1ItemSet, itemSetList, minSup, globalItemSetWithSup)\n",
    "    currentLSet = L1ItemSet\n",
    "    k = 2\n",
    "\n",
    "    # Calculating frequent item set\n",
    "    while(currentLSet):\n",
    "        # Storing frequent itemset\n",
    "        globalFreqItemSet[k-1] = currentLSet\n",
    "        # Self-joining Lk\n",
    "        candidateSet = getUnion(currentLSet, k)\n",
    "        # Perform subset testing and remove pruned supersets\n",
    "        candidateSet = pruning(candidateSet, currentLSet, k-1)\n",
    "        # Scanning itemSet for counting support\n",
    "        currentLSet = getAboveMinSup(\n",
    "            candidateSet, itemSetList, minSup, globalItemSetWithSup)\n",
    "        k += 1\n",
    "\n",
    "    rules = associationRule(globalFreqItemSet, globalItemSetWithSup, minConf)\n",
    "    rules.sort(key=lambda x: x[2])\n",
    "\n",
    "    return globalFreqItemSet, rules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8ee83d1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def powerset(s):\n",
    "    return chain.from_iterable(combinations(s, r) for r in range(1, len(s)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "2887a2fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getFromFile(fname):\n",
    "    itemSets = []\n",
    "    itemSet = set()\n",
    "\n",
    "    with open(fname, 'r') as file:\n",
    "        csv_reader = reader(file)\n",
    "        for line in csv_reader:\n",
    "            line = list(filter(None, line))\n",
    "            record = set(line)\n",
    "            for item in record:\n",
    "                itemSet.add(frozenset([item]))\n",
    "            itemSets.append(record)\n",
    "    return itemSet, itemSets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f9565ada",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getAboveMinSup(itemSet, itemSetList, minSup, globalItemSetWithSup):\n",
    "    freqItemSet = set()\n",
    "    localItemSetWithSup = defaultdict(int)\n",
    "\n",
    "    for item in itemSet:\n",
    "        for itemSet in itemSetList:\n",
    "            if item.issubset(itemSet):\n",
    "                globalItemSetWithSup[item] += 1\n",
    "                localItemSetWithSup[item] += 1\n",
    "\n",
    "    for item, supCount in localItemSetWithSup.items():\n",
    "        support = float(supCount / len(itemSetList))\n",
    "        if(support >= minSup):\n",
    "            freqItemSet.add(item)\n",
    "\n",
    "    return freqItemSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e2fb604e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getUnion(itemSet, length):\n",
    "    return set([i.union(j) for i in itemSet for j in itemSet if len(i.union(j)) == length])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "13e91051",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pruning(candidateSet, prevFreqSet, length):\n",
    "    tempCandidateSet = candidateSet.copy()\n",
    "    for item in candidateSet:\n",
    "        subsets = combinations(item, length)\n",
    "        for subset in subsets:\n",
    "            # if the subset is not in previous K-frequent get, then remove the set\n",
    "            if(frozenset(subset) not in prevFreqSet):\n",
    "                tempCandidateSet.remove(item)\n",
    "                break\n",
    "    return tempCandidateSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9ad0970f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def FassociationRule(freqItemSet, itemSetWithSup, minConf):\n",
    "    rules = []\n",
    "    for k, itemSet in freqItemSet.items():\n",
    "        for item in itemSet:\n",
    "            subsets = powerset(item)\n",
    "            for s in subsets:\n",
    "                confidence = float(\n",
    "                    itemSetWithSup[item] / itemSetWithSup[frozenset(s)])\n",
    "                if(confidence > minConf):\n",
    "                    rules.append([set(s), set(item.difference(s)), confidence])\n",
    "    return rules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "3edfe7aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getItemSetFromList(itemSetList):\n",
    "    tempItemSet = set()\n",
    "\n",
    "    for itemSet in itemSetList:\n",
    "        for item in itemSet:\n",
    "            tempItemSet.add(frozenset([item]))\n",
    "\n",
    "    return tempItemSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "9cc11b9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "g_sequence1=list()\n",
    "g_sequence2=list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b3d26567",
   "metadata": {},
   "outputs": [],
   "source": [
    "count=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d1c3ed93",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(input_file1) as file1:\n",
    "    for lineno in file1:\n",
    "        if count==3 or count==70 or count ==94 or count==115 or count==130 or count==139 or count==328 or count==415:\n",
    "            lineno = list(lineno)\n",
    "            lineno.remove(\"\\n\")\n",
    "            g_sequence1.append(lineno)\n",
    "            count+=1\n",
    "        else:\n",
    "            count+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "f407841d",
   "metadata": {},
   "outputs": [],
   "source": [
    "count1=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "4f9d9be5",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(input_file2) as file2:\n",
    "    for lineno in file2:\n",
    "        if count1==3 or count1==70 or count1 ==94 or count1==115 or count1==130 or count1==139 or count1==328 or count1==415:\n",
    "            lineno = list(lineno)\n",
    "            lineno.remove(\"\\n\")\n",
    "            g_sequence2.append(lineno)\n",
    "            count1+=1\n",
    "        else:\n",
    "            count1+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "e89764bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "freqItemSet, rules = Fapriori(g_sequence1, minSup=.5, minConf=.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "853f3736",
   "metadata": {},
   "outputs": [],
   "source": [
    "freqItemSet1, rules1 = Fapriori(g_sequence2, minSup=.5, minConf=.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "0866f8fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(freqItemSet,rules)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "a49cba4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(freqItemSet1,rules1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "5ce84ad2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#len(freqItemSet1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "4e82df43",
   "metadata": {},
   "outputs": [],
   "source": [
    "#freqItemSet, rules = fpgrowth(g_sequence1,minSupRatio=0.5,minConf=0.5)\n",
    "#print(rules) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "1cdf0bc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "corona=''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "9e61ca11",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(input_file1) as file1:\n",
    "    for lineno in file1:\n",
    "        corona+=lineno"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "2ca062e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "for a in \" \\n0123456789\":\n",
    "    corona = corona.replace(a, \"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d0c69e5f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42483"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(corona)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "e83ce4af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9579"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(zlib.compress(corona.encode(\"utf-8\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "8b60ad48",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8292"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lzc = lzma.compress(corona.encode(\"utf-8\"))\n",
    "len(lzc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "93071057",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Ala / A', 'GCU, GCC, GCA, GCG']\n",
      "['Ile / I', 'AUU, AUC, AUA']\n",
      "['Arg / R', 'CGU, CGC, CGA, CGG; AGA, AGG, AGR;']\n",
      "['Leu / L', 'CUU, CUC, CUA, CUG; UUA, UUG, UUR;']\n",
      "['Asn / N', 'AAU, AAC']\n",
      "['Lys / K', 'AAA, AAG']\n",
      "['Asp / D', 'GAU, GAC']\n",
      "['Met / M', 'AUG']\n",
      "['Phe / F', 'UUU, UUC']\n",
      "['Cys / C', 'UGU, UGC']\n",
      "['Pro / P', 'CCU, CCC, CCA, CCG']\n",
      "['Gln / Q', 'CAA, CAG']\n",
      "['Ser / S', 'UCU, UCC, UCA, UCG; AGU, AGC;']\n",
      "['Glu / E', 'GAA, GAG']\n",
      "['Thr / T', 'ACU, ACC, ACA, ACG']\n",
      "['Trp / W', 'UGG']\n",
      "['Gly / G', 'GGU, GGC, GGA, GGG']\n",
      "['Tyr / Y', 'UAU, UAC']\n",
      "['His / H', 'CAU, CAC']\n",
      "['Val / V', 'GUU, GUC, GUA, GUG']\n",
      "['STOP', 'UAA, UGA, UAG']\n"
     ]
    }
   ],
   "source": [
    "# Asn or Asp / B\tAAU, AAC; GAU, GAC\n",
    "# Gln or Glu / Z\tCAA, CAG; GAA, GAG\n",
    "# START\tAUG\n",
    "## Seperating them from the table because these duplicates was creating problems\n",
    "codons = \"\"\"\n",
    "Ala / A\tGCU, GCC, GCA, GCG\n",
    "Ile / I\tAUU, AUC, AUA\n",
    "Arg / R\tCGU, CGC, CGA, CGG; AGA, AGG, AGR;\n",
    "Leu / L\tCUU, CUC, CUA, CUG; UUA, UUG, UUR;\n",
    "Asn / N\tAAU, AAC\n",
    "Lys / K\tAAA, AAG\n",
    "Asp / D\tGAU, GAC\n",
    "Met / M\tAUG\n",
    "Phe / F\tUUU, UUC\n",
    "Cys / C\tUGU, UGC\n",
    "Pro / P\tCCU, CCC, CCA, CCG\n",
    "Gln / Q\tCAA, CAG\n",
    "Ser / S\tUCU, UCC, UCA, UCG; AGU, AGC;\n",
    "Glu / E\tGAA, GAG\n",
    "Thr / T\tACU, ACC, ACA, ACG\n",
    "Trp / W\tUGG\n",
    "Gly / G\tGGU, GGC, GGA, GGG\n",
    "Tyr / Y\tUAU, UAC\n",
    "His / H\tCAU, CAC\n",
    "Val / V\tGUU, GUC, GUA, GUG\n",
    "STOP\tUAA, UGA, UAG\"\"\".strip()\n",
    "\n",
    "for t in codons.split('\\n'):\n",
    "    print(t.split('\\t'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "07b1ad19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'gct': 'A',\n",
       " 'gcc': 'A',\n",
       " 'gca': 'A',\n",
       " 'gcg': 'A',\n",
       " 'att': 'I',\n",
       " 'atc': 'I',\n",
       " 'ata': 'I',\n",
       " 'cgt': 'R',\n",
       " 'cgc': 'R',\n",
       " 'cga': 'R',\n",
       " 'cgg': 'R',\n",
       " 'aga': 'R',\n",
       " 'agg': 'R',\n",
       " 'agr': 'R',\n",
       " 'ctt': 'L',\n",
       " 'ctc': 'L',\n",
       " 'cta': 'L',\n",
       " 'ctg': 'L',\n",
       " 'tta': 'L',\n",
       " 'ttg': 'L',\n",
       " 'ttr': 'L',\n",
       " 'aat': 'N',\n",
       " 'aac': 'N',\n",
       " 'aaa': 'K',\n",
       " 'aag': 'K',\n",
       " 'gat': 'D',\n",
       " 'gac': 'D',\n",
       " 'atg': 'M',\n",
       " 'ttt': 'F',\n",
       " 'ttc': 'F',\n",
       " 'tgt': 'C',\n",
       " 'tgc': 'C',\n",
       " 'cct': 'P',\n",
       " 'ccc': 'P',\n",
       " 'cca': 'P',\n",
       " 'ccg': 'P',\n",
       " 'caa': 'Q',\n",
       " 'cag': 'Q',\n",
       " 'tct': 'S',\n",
       " 'tcc': 'S',\n",
       " 'tca': 'S',\n",
       " 'tcg': 'S',\n",
       " 'agt': 'S',\n",
       " 'agc': 'S',\n",
       " 'gaa': 'E',\n",
       " 'gag': 'E',\n",
       " 'act': 'T',\n",
       " 'acc': 'T',\n",
       " 'aca': 'T',\n",
       " 'acg': 'T',\n",
       " 'tgg': 'W',\n",
       " 'ggt': 'G',\n",
       " 'ggc': 'G',\n",
       " 'gga': 'G',\n",
       " 'ggg': 'G',\n",
       " 'tat': 'Y',\n",
       " 'tac': 'Y',\n",
       " 'cat': 'H',\n",
       " 'cac': 'H',\n",
       " 'gtt': 'V',\n",
       " 'gtc': 'V',\n",
       " 'gta': 'V',\n",
       " 'gtg': 'V',\n",
       " 'taa': '*',\n",
       " 'tga': '*',\n",
       " 'tag': '*'}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##decoder dictionary\n",
    "dec = {}  \n",
    "\n",
    "for t in codons.split('\\n'):\n",
    "    k, v = t.split('\\t')\n",
    "    if '/' in k:\n",
    "        k = k.split('/')[-1].strip()\n",
    "    k = k.replace(\"STOP\", \"*\")\n",
    "    v = v.replace(\",\", \"\").replace(\";\", \"\").lower().replace(\"u\", \"t\").split(\" \")\n",
    "    for vv in v:\n",
    "        if vv in dec:\n",
    "            print(\"duplicate\", vv)\n",
    "        dec[vv] = k\n",
    "dec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "6356f936",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set(dec.values())) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "885b0a70",
   "metadata": {},
   "outputs": [],
   "source": [
    "genome_sequence1=''\n",
    "genome_sequence2=''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "59228e84",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_seq_1 = read_dna_seq('./input/China_Seq_2019_Dec.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "f915174f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modify the sequence with dummy 'N' nucleotide.\n",
    "dict_seq_1 = gene_mod(dict_seq_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "52877d77",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the dna sequence file-2 previously downloaded from NCBI.\n",
    "dict_seq_2 = read_dna_seq('./input/USA_Seq_2020_Jan.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "99cded28",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modify the sequence with dummy 'N' nucleotide.\n",
    "dict_seq_2 = gene_mod(dict_seq_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "42a90ebd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1800x2160 with 33 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create matplotlib subplots for each gene. \n",
    "f,ax = plt.subplots(nrows=11,ncols=3,figsize=(25,30))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "ae69f7f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "gene_name = list(numpy_image_dict.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "8c13dd17",
   "metadata": {},
   "outputs": [],
   "source": [
    "row = 0\n",
    "col = 0\n",
    "mut_dict={}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "7dc4b45f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mutated DNA Base 255 in China and Base 100 in USA at position (74, 6) For the Gene ORF1ab\n",
      "Mutated DNA Base 100 in China and Base 255 in USA at position (12, 10) For the Gene ORF8\n",
      "Mutated DNA Base 255 in China and Base 0 in USA at position (17, 24) For the Gene N\n"
     ]
    }
   ],
   "source": [
    "for i in gene_name:\n",
    "    G = i[5:]\n",
    "    # Loop thru each gene in the Cornona Virus nucleotide sequence.\n",
    "    gene_us = dna(dict_seq_1['gene='+G][1])\n",
    "    # Invoke the transcription method of the class dna \n",
    "    gene_us.transcription()\n",
    "    # Invoke the mothod that converts the gene sequence into a numpy array.\n",
    "    numpfy_usa = gene_us.numpfy()\n",
    "    # Reshape the numpy array with a predeifned shape from the numpy_image_dict dictionary.\n",
    "    numpfy_usa = numpfy_usa.reshape(numpy_image_dict['gene='+G][0])\n",
    "    # sub-plot the numpy array with matplotlib pcolor method.\n",
    "    ax[row][col].pcolor(numpfy_usa)\n",
    "    ax[row][col].set_title(G+' Gene - USA')\n",
    "    col+=1\n",
    "    gene_china = dna(dict_seq_2['gene='+G][1])\n",
    "    # Invoke the transcription method of the class dna \n",
    "    gene_china.transcription()\n",
    "    # Invoke the mothod that converts the gene sequence into a numpy array.\n",
    "    numpfy_china = gene_china.numpfy()\n",
    "    # Reshape the numpy array with a predeifned shape from the numpy_image_dict dictionary.\n",
    "    numpfy_china = numpfy_china.reshape(numpy_image_dict['gene='+G][0])\n",
    "    # sub-plot the numpy array with matplotlib pcolor method.\n",
    "    ax[row][col].pcolor(numpfy_china)\n",
    "    ax[row][col].set_title(G+' Gene - CHINA')\n",
    "    col+=1\n",
    "\n",
    "    # To find the gene mutation subtract the numpy array from base sequence with the newer sequence. Here the \n",
    "    # the Chinese sequence is the base sequence and the USA sequence is a newer sequence.\n",
    "    mut = numpfy_china - numpfy_usa\n",
    "    if mut.any():\n",
    "        # Here we are looking for a non zero value in the mutated numpy array (result of the subtracting the 2 numpy arrays).\n",
    "        # Presence of non-zero value means that there is difference between the 2 numpy arrays and the gene has \n",
    "        # mutataions. If there are mutations in the gene create a python dictionary \"mut_dict\" with details as below.\n",
    "        # {'<Gene_Name-1>': [[<value_of_base_seq>, <value_of_newer_seq>, <value_in_mutated_numpy>, (x_value,y_value)]], '<Gene_Name-2>': [[<value_of_base_seq>, <value_of_newer_seq>, <value_in_mutated_numpy>, (x_value,y_value)]]}\n",
    "        mut_nec = np.nonzero(mut)\n",
    "        x=mut_nec[0]\n",
    "        y=mut_nec[1]\n",
    "        l=0\n",
    "        mut_dict[G]=[]\n",
    "        for i in x:\n",
    "            us_base = numpfy_usa[i][y[l]]\n",
    "            ch_base = numpfy_china[i][y[l]]\n",
    "            mut_base = mut[i][y[l]]\n",
    "            info_list = [ch_base,us_base,mut_base,(i,y[l])]\n",
    "            mut_dict[G].append(info_list)\n",
    "            print(\"Mutated DNA Base {} in China and Base {} in USA at position {} For the Gene {}\".format(ch_base,us_base,(i,y[l]),G))\n",
    "            l+= 1\n",
    "    # Giving a title to the matplotlib subplot\n",
    "    ax[row][col].pcolor(mut)\n",
    "    ax[row][col].set_title(G+' Gene - Mutataion')\n",
    "    row+= 1\n",
    "    col=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "01150db9",
   "metadata": {},
   "outputs": [],
   "source": [
    "f.tight_layout()\n",
    "# Saving the matplotlib subplot as a jpg.\n",
    "f.savefig('./output/Gene_Mutation_Analysis.jpg')"
   ]
  }
 ],
 "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}