TALE_Writer_2022-06-17.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ready\n"
     ]
    }
   ],
   "source": [
    "# LIBRARIES, FUNCTIONS, AND INITIALIZATIONS\n",
    "\n",
    "# Libraries\n",
    "from colorama import Back, Style\n",
    "import matplotlib.pyplot as plt\n",
    "from tabulate import tabulate\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import sys\n",
    "\n",
    "# Find reverse complement\n",
    "def reverse_complement(sequence):\n",
    "    sequence, newSequence = sequence.lower(), ''\n",
    "    for i in range(0,len(sequence)):\n",
    "        # Unambiguous\n",
    "        if sequence[i] == 'a': newSequence = newSequence + 't'\n",
    "        elif sequence[i] == 'c': newSequence = newSequence + 'g'\n",
    "        elif sequence[i] == 'g': newSequence = newSequence + 'c'\n",
    "        elif sequence[i] == 't': newSequence = newSequence + 'a'\n",
    "        # Ambiguous\n",
    "        elif sequence[i] == 'r': newSequence = newSequence + 'y'\n",
    "        elif sequence[i] == 'y': newSequence = newSequence + 'r'\n",
    "        elif sequence[i] == 'k': newSequence = newSequence + 'm'\n",
    "        elif sequence[i] == 'm': newSequence = newSequence + 'k'\n",
    "        elif sequence[i] == 's': newSequence = newSequence + 's'\n",
    "        elif sequence[i] == 'w': newSequence = newSequence + 'w'\n",
    "        elif sequence[i] == 'b': newSequence = newSequence + 'v'\n",
    "        elif sequence[i] == 'd': newSequence = newSequence + 'h'\n",
    "        elif sequence[i] == 'h': newSequence = newSequence + 'd'\n",
    "        elif sequence[i] == 'v': newSequence = newSequence + 'b'\n",
    "        elif sequence[i] == 'n': newSequence = newSequence + 'n'\n",
    "    newSequence = newSequence[::-1]\n",
    "    return newSequence\n",
    "\n",
    "# Disambiguate DNA sequence\n",
    "def disambiguate(sequence):\n",
    "    sequence = sequence.lower()\n",
    "    # Calculate number of variations\n",
    "    ambiguous_list = ['R','Y','K','M','S','W','B','D','H','V','N']\n",
    "    possibilities_list = [2,2,2,2,2,2,3,3,3,3,4]\n",
    "    times_list, variations = [], 1\n",
    "    for i in range(0,len(ambiguous_list)):\n",
    "        times_list.append(sequence.count(ambiguous_list[i].lower()))\n",
    "        if times_list[i] != 0: variations = variations*possibilities_list[i]**times_list[i]\n",
    "    # Calculate all variations (disambiguate)\n",
    "    interrogate_list, i, stop1 = [], 0, False\n",
    "    interrogate_list.append(sequence)\n",
    "    while stop1 == False:\n",
    "        stop2, j = False, 0\n",
    "        while stop2 == False:\n",
    "            # Double-check that disambiguation is required\n",
    "            c = 0\n",
    "            for k in range(0,len(ambiguous_list)):\n",
    "                if (interrogate_list[i].find(ambiguous_list[k].lower()) == -1) == False: c += 1\n",
    "            if c == 0: stop1, stop2 = True, True\n",
    "            # Disambiguate symbol-by-symbol\n",
    "            if stop1 == False:\n",
    "                if interrogate_list[i][j] not in {'a','c','g','t'}: # If symbol is ambiguous\n",
    "                    stop2 = True    \n",
    "                    if interrogate_list[i][j] == 'r': # Disambiguate symbol\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'a' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'g' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                    elif interrogate_list[i][j] == 'y':\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'c' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 't' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                    elif interrogate_list[i][j] == 'k':\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'g' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 't' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                    elif interrogate_list[i][j] == 'm':\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'a' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'c' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                    elif interrogate_list[i][j] == 's':\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'c' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'g' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                    elif interrogate_list[i][j] == 'w':\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'a' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 't' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                    elif interrogate_list[i][j] == 'b':\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'c' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'g' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 't' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                    elif interrogate_list[i][j] == 'd':\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'a' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'g' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 't' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                    elif interrogate_list[i][j] == 'h':\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'a' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'c' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 't' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                    elif interrogate_list[i][j] == 'v':\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'a' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'c' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'g' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                    elif interrogate_list[i][j] == 'n':\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'a' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'c' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 'g' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                        interrogate_list.append(interrogate_list[i][0:j] + 't' + interrogate_list[i][j+1:len(interrogate_list[i])])\n",
    "                elif interrogate_list[i][j] in {'a','c','g','t'}: # If symbol is unambiguous\n",
    "                    j += 1  \n",
    "        i += 1 \n",
    "    # Get rid of ambiguous seeds\n",
    "    variations_list = []\n",
    "    for i in range(len(interrogate_list)-variations,len(interrogate_list)): \n",
    "        variations_list.append(interrogate_list[i])\n",
    "    return variations_list\n",
    "\n",
    "# Align two sequences ('recognition' must be in 'sequence')\n",
    "def align(sequence, recognition):\n",
    "    sequence, recognition = sequence.lower(), recognition.lower()\n",
    "    x, y = 0, len(recognition)\n",
    "    i, j = 0, 0\n",
    "    while x < y:\n",
    "        if sequence[i] != recognition[j]:\n",
    "            recognition = ' ' + recognition\n",
    "            i, j = i + 1, j + 1\n",
    "            for k in range(0, x): \n",
    "                i, j = i - 1, j - 1\n",
    "            x = 0\n",
    "        elif sequence[i] == recognition[j]: \n",
    "            i, j, x = i + 1, j + 1, x + 1\n",
    "    z = len(recognition) - len(recognition.lstrip())\n",
    "    return [recognition, z]\n",
    "\n",
    "# Enzymes and their recognition sequences\n",
    "enzymes_list = ['AatII','Acc65I','AccI','AciI','AclI','AfeI','AflII','AflIII','AgeI','AhdI','AleI','AluI','AlwNI','ApaI','ApaLI','ApeKI','ApoI','AscI','AseI','AsiSI','AvaI','AvaII','AvrII','BaeGI','BamHI','BanI','BanII','BbvCI','BclI','BfaI','BglI','BglII','BlpI','BmgBI','BmtI','Bpu10I','BsaAI','BsaBI','BsaHI','BsaJI','BsaWI','BseYI','BsiEI','BsiHKAI','BsiWI','BslI','BsoBI','Bsp1286I','BspDI','BspEI','BspHI','BsrBI','BsrFI','BsrGI','BssHII','BssSI','BstAPI','BstBI','BstEII','BstNI','BstUI','BstXI','BstYI','BstZ17I','Bsu36I','BtgI','Cac8I','ClaI','CviAII','CviKI-1','CviQI','DdeI','DpnII','DraI','DraIII','DrdI','EaeI','EagI','Eco53kI','EcoNI','EcoO109I','EcoRI','EcoRV','FatI','Fnu4HI','FseI','FspI','HaeII','HaeIII','HhaI','HinP1I','HincII','HindIII','HinfI','HpaI','HpaII','Hpy166II','Hpy188I','Hpy188III','Hpy99I','HpyCH4III','HpyCH4IV','HpyCH4V','I-CeuI','I-SceI','KasI','KpnI','MboI','MfeI','MluCI','MluI','MscI','MseI','MslI','MspA1I','MspI','MwoI','NaeI','NarI','NciI','NcoI','NdeI','NgoMIV','NheI','NlaIII','NlaIV','NotI','NruI','NsiI','NspI','PI-PspI','PI-SceI','PacI','PaeR7I','PciI','PflFI','PflMI','PluTI','PmeI','PmlI','PpuMI','PshAI','PsiI','PspGI','PspOMI','PspXI','PstI','PvuI','PvuII','RsaI','RsrII','SacI','SacII','SalI','Sau3AI','Sau96I','SbfI','ScaI','ScrFI','SexAI','SfcI','SfiI','SfoI','SgrAI','SmaI','SmlI','SnaBI','SpeI','SphI','SrfI','SspI','StuI','StyD4I','StyI','SwaI','TaqI','TfiI','TseI','Tsp45I','TspMI','TspRI','Tth111I','XbaI','XcmI','XhoI','XmaI','XmnI','ZraI','AcuI','AlwI','BaeI','BbsI','BbvI','BccI','BceAI','BcgI','BciVI','BcoDI','BfuAI','BmrI','BpmI','BpuEI','BsaI','BsaXI','BseRI','BsgI','BsmAI','BsmBI','BsmFI','BsmI','BspCNI','BspMI','BspQI','BsrDI','BsrI','BtgZI','BtsCI','BtsI','BtsIMutI','CspCI','EarI','EciI','Esp3I','FauI','FokI','HgaI','HphI','HpyAV','MboII','MlyI','MmeI','MnlI','NmeAIII','PaqCI','PleI','SapI','SfaNI']\n",
    "recognition_list, complements_list = ['GACGTC','GGTACC','GTMKAC','CCGC','AACGTT','AGCGCT','CTTAAG','ACRYGT','ACCGGT','GACNNNNNGTC','CACNNNNGTG','AGCT','CAGNNNCTG','GGGCCC','GTGCAC','GCWGC','RAATTY','GGCGCGCC','ATTAAT','GCGATCGC','CYCGRG','GGWCC','CCTAGG','GKGCMC','GGATCC','GGYRCC','GRGCYC','CCTCAGC','TGATCA','CTAG','GCCNNNNNGGC','AGATCT','GCTNAGC','CACGTC','GCTAGC','CCTNAGC','YACGTR','GATNNNNATC','GRCGYC','CCNNGG','WCCGGW','CCCAGC','CGRYCG','GWGCWC','CGTACG','CCNNNNNNNGG','CYCGRG','GDGCHC','ATCGAT','TCCGGA','TCATGA','CCGCTC','RCCGGY','TGTACA','GCGCGC','CACGAG','GCANNNNNTGC','TTCGAA','GGTNACC','CCWGG','CGCG','CCANNNNNNTGG','RGATCY','GTATAC','CCTNAGG','CCRYGG','GCNNGC','ATCGAT','CATG','RGCY','GTAC','CTNAG','GATC','TTTAAA','CACNNNGTG','GACNNNNNNGTC','YGGCCR','CGGCCG','GAGCTC','CCTNNNNNAGG','RGGNCCY','GAATTC','GATATC','CATG','GCNGC','GGCCGGCC','TGCGCA','RGCGCY','GGCC','GCGC','GCGC','GTYRAC','AAGCTT','GANTC','GTTAAC','CCGG','GTNNAC','TCNGA','TCNNGA','CGWCG','ACNGT','ACGT','TGCA','TAACTATAACGGTCCTAAGGTAGCGAA','TAGGGATAACAGGGTAAT','GGCGCC','GGTACC','GATC','CAATTG','AATT','ACGCGT','TGGCCA','TTAA','CAYNNNNRTG','CMGCKG','CCGG','GCNNNNNNNGC','GCCGGC','GGCGCC','CCSGG','CCATGG','CATATG','GCCGGC','GCTAGC','CATG','GGNNCC','GCGGCCGC','TCGCGA','ATGCAT','RCATGY','TGGCAAACAGCTATTATGGGTATTATGGGT','ATCTATGTCGGGTGCGGAGAAAGAGGTAATGAAATGG','TTAATTAA','CTCGAG','ACATGT','GACNNNGTC','CCANNNNNTGG','GGCGCC','GTTTAAAC','CACGTG','RGGWCCY','GACNNNNGTC','TTATAA','CCWGG','GGGCCC','VCTCGAGB','CTGCAG','CGATCG','CAGCTG','GTAC','CGGWCCG','GAGCTC','CCGCGG','GTCGAC','GATC','GGNCC','CCTGCAGG','AGTACT','CCNGG','ACCWGGT','CTRYAG','GGCCNNNNNGGCC','GGCGCC','CRCCGGYG','CCCGGG','CTYRAG','TACGTA','ACTAGT','GCATGC','GCCCGGGC','AATATT','AGGCCT','CCNGG','CCWWGG','ATTTAAAT','TCGA','GAWTC','GCWGC','GTSAC','CCCGGG','CASTG','GACNNNGTC','TCTAGA','CCANNNNNNNNNTGG','CTCGAG','CCCGGG','GAANNNNTTC','GACGTC','CTGAAG','GGATC','ACNNNNGTAYC','GAAGAC','GCAGC','CCATC','ACGGC','CGANNNNNNTGC','GTATCC','GTCTC','ACCTGC','ACTGGG','CTGGAG','CTTGAG','GGTCTC','ACNNNNNCTCC','GAGGAG','GTGCAG','GTCTC','CGTCTC','GGGAC','GAATGC','CTCAG','ACCTGC','GCTCTTC','GCAATG','ACTGG','GCGATG','GGATG','GCAGTG','CAGTG','CAANNNNNGTGG','CTCTTC','GGCGGA','CGTCTC','CCCGC','GGATG','GACGC','GGTGA','CCTTC','GAAGA','GAGTC','TCCRAC','CCTC','GCCGAG','CACCTGC','GAGTC','GCTCTTC','GCATC'], []\n",
    "for i in range(0,len(recognition_list)): \n",
    "    recognition_list[i] = recognition_list[i].lower()\n",
    "    complements_list.append(reverse_complement((recognition_list[i])))\n",
    "# Enzymes with unambiguous recognition sequences\n",
    "fullEnzymes_list, fullRecognition_list, fullComplements_list = [], [], []\n",
    "for i in range(0,len(recognition_list)):\n",
    "    x = len(disambiguate(recognition_list[i]))\n",
    "    if x == 1:\n",
    "        fullEnzymes_list.append(enzymes_list[i])\n",
    "        fullRecognition_list.append(recognition_list[i])\n",
    "        fullComplements_list.append(complements_list[i])\n",
    "    elif x > 1:\n",
    "        if x <= 256: # Cutoff to decrease computation time\n",
    "            if recognition_list[i] == complements_list[i]:\n",
    "                for j in range(0,x):\n",
    "                    fullEnzymes_list.append(enzymes_list[i])\n",
    "                    y = disambiguate(recognition_list[i])[j]\n",
    "                    fullRecognition_list.append(y)\n",
    "                    fullComplements_list.append(y)\n",
    "            elif recognition_list[i] != complements_list[i]:\n",
    "                for j in range(0,x):\n",
    "                    fullEnzymes_list.append(enzymes_list[i])\n",
    "                    fullRecognition_list.append(disambiguate(recognition_list[i])[j])\n",
    "                    fullComplements_list.append(disambiguate(complements_list[i])[j])\n",
    "print('Ready')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Design:\n",
      "A. TALENs\n",
      "B. DdCBEs (DddA)\n",
      "C. DdCBEs (DddA11)\n",
      "C\n",
      "\n",
      "Base editors for:\n",
      "A. All potential targets\n",
      "B. Specific site\n",
      "C. PTCs\n",
      "C\n",
      "\n",
      "Use default design parameters? YES\n",
      "\n",
      "Left arm minimum length (bp): 15\n",
      "Left arm maximum length (bp): 16\n",
      "Left 5'-T constraint: Yes\n",
      "\n",
      "Spacer minimum length (bp): 14\n",
      "Spacer maximum length (bp): 16\n",
      "\n",
      "Right arm minimum length (bp): 15\n",
      "Right arm maximum length (bp): 16\n",
      "Right 5'-T constraint: Yes\n",
      "\n",
      "Target window: 4\n",
      "\n",
      "--------------\n",
      "SEQUENCE NO. 1\n",
      "--------------\n",
      "\n",
      "Sequence (5'-to-3'): atgcccctcatttacataaatattatactagcatttaccatctcacttctaggaatactagtatatcgctcacacctcatatcctccctactatgcctagaaggaataatactatcgctgttcattatagctactctcataaccctcaacacccactccctcttagccaatattgtgcctattgccatactagtctttgccgcctgcgaagcagcggtgggcctagccctactagtctcaatctccaacacatatggcctagactacgtacataacctaaacctactccaatgctaa\n",
      "\n",
      "Sequence (with target/s): atgcccctcatttacataaatattatactagcatttaccatctcacttcta\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0matactagtatatcgctcacacctcatatcctccctactatgcctagaa\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mataatactatcgctgttcattatagctactctcataaccctcaacacccactccctcttagccaatattgtgcctattgccatactagtctttgccgcctgcgaagcagcggtgggcctagccctactagtctcaatctccaacacatatggcctagactacgtacataacctaaacctactccaatgctaa\n",
      "\n",
      "  TGT    COORD    DSG  LOSS    GAIN      OFF  LEFT SEQUENCE     RIGHT SEQUENCE    SPACER SEQUENCE\n",
      "-----  -------  -----  ------  ------  -----  ----------------  ----------------  -----------------\n",
      "    1       52      1  Yes     No          3  agcatttaccatctc   gtgagcgatatacta   \u001b[41mac\u001b[0mt\u001b[41mtc\u001b[0mta\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mat\u001b[41mac\u001b[0m\n",
      "    1       52      2  Yes     No          3  actagcatttaccatc  gtgagcgatatactag  \u001b[41mtc\u001b[0m\u001b[41mac\u001b[0mt\u001b[41mtc\u001b[0mta\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mata\n",
      "    1       52      3  Yes     No          3  actagcatttaccat   gtgagcgatatactag  c\u001b[41mtc\u001b[0m\u001b[41mac\u001b[0mt\u001b[41mtc\u001b[0mta\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mata\n",
      "    1       52      4  Yes     No          4  actagcatttaccatc  gtgagcgatatacta   \u001b[41mtc\u001b[0m\u001b[41mac\u001b[0mt\u001b[41mtc\u001b[0mta\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mat\u001b[41mac\u001b[0m\n",
      "    2      103      1  Yes     No          1  cctccctactatgcc   aatgaacagcgatag   ta\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mataata\n",
      "    2      103      2  Yes     No          2  cctccctactatgcct  ataatgaacagcgata  a\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mataat\u001b[41mac\u001b[0m\n",
      "    2      103      3  Yes     No          1  atcctccctactatgc  aatgaacagcgatagt  cta\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mataat\n",
      "    2      103      4  Yes     No          2  cctccctactatgcc   ataatgaacagcgata  ta\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mataat\u001b[41mac\u001b[0m\n",
      "    2      103      5  Yes     No          2  atcctccctactatg   aatgaacagcgatagt  \u001b[41mcc\u001b[0mta\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mataat\n",
      "    2      103      6  Yes     No          2  cctccctactatgcct  ataatgaacagcgat   a\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mataat\u001b[41mac\u001b[0mt\n",
      "    2      103      7  Yes     No          1  atcctccctactatgc  aatgaacagcgatag   cta\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mataata\n",
      "    2      103      8  Yes     No          2  catatcctccctacta  gaacagcgatagtat   tg\u001b[41mcc\u001b[0mta\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mata\n",
      "    2      103      9  Yes     No          2  cctccctactatgcc   ataatgaacagcgat   ta\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mataat\u001b[41mac\u001b[0mt\n",
      "    2      103     10  Yes     No          2  atcctccctactatg   aatgaacagcgatag   \u001b[41mcc\u001b[0mta\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mataata\n",
      "    2      103     11  Yes     No          2  catatcctccctact   gaacagcgatagtat   atg\u001b[41mcc\u001b[0mta\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mata\n",
      "    2      103     12  Yes     No          2  atcctccctactatgc  ataatgaacagcgata  cta\u001b[41mga\u001b[0ma\u001b[44mG\u001b[0m\u001b[44mG\u001b[0m\u001b[44mA\u001b[0mataat\u001b[41mac\u001b[0m\n",
      "\n",
      "There are 2 potential targets and a total of 16 design permutations.\n",
      "\n",
      "Design permutation distribution:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAF3CAYAAADtkpxQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xt0VXd+3/3PF8T9joW5C8RVYBnQluJ6eTwel7GxjWGwjTH22MPgYQaMmckk7VrNpPM8mbRpV9MnfXJpmiZxM6mbp8n0STOTZCZPEidPmzTp6nhS9k93JCGuMoirASEQoNu3f0hDGZuLAJ3zO9J5v9ZiobPP1tkfeyPOh+/eZ29zdwEAACC7RsQOAAAAkI8oYQAAABFQwgAAACKghAEAAERACQMAAIiAEgYAABABJQwAACACShgAAEAElDAAAIAIKGEAAAARFMQOMBCFhYW+cOHC2DEAAADuKE3Ts+4+407rDYkStnDhQu3duzd2DAAAgDsys6MDWY/DkQAAABFQwgAAACKghAEAAERACQMAAIiAEgYAABABJQwAACACShgAAEAElDAAAIAIKGEAAAARUMIAAAAioIQBAABEQAkDAACIgBIGAAAQASUMAAAgAkoYAABABJQwAACACChhAAAAEVDCAAAAIqCEAQAARJCxEmZmv21mp82s7oZlv2BmjWZWY2Z/aGZTM7V9AACAXJbJSdi7kp79yLK/lFTq7qsk7Zf00xncPgAAQM7KWAlz97+RdO4jy/7C3bv7H74vaV6mtg8AAJDLYp4T9gVJfxZx+wAAYJjr7u5WXV2dvv71r2vGjBnas2dP7EjXRSlhZvZ1Sd2Sfvc26+w0s71mtvfMmTPZCwcAAIa8s2fP6r333tMv/dIvqbKyUt/73vd0/vx5/eZv/mbsaNcVZHuDZvZ5SRskfdrd/Vbrufs7kt6RpIqKiluuBwAAIEldXV1qaGhQmqY6d+6cVq9erR07dmj69Ol6//33tW/fPu3atSt2zOvsNj3o/l/cbKGkP3H30v7Hz0r6RUmfcvcBj7cqKip87969GckIAACGttOnTytNU9XW1mru3LlKkkTLli3TyJEjo+Qxs9TdK+60XsYmYWb2LUlPSio0s2OSvqG+T0OOkfSXZiZJ77v7W5nKAAAAhqeuri7V19crTVO1tbVpzZo12rlzp6ZOHTpXv8pYCXP3126y+JuZ2h4AABj+Tp48qRCC6urqNG/ePD3++ONaunSpRowYetefz/o5YQAAAHejs7NTdXV1CiGovb1dZWVl2rVrl6ZMmRI72n2hhAEAgJzU2tqqEILq6+u1YMECfepTn9LixYuH5NTrZihhAAAgZ1y7dk21tbUKIaijo0NJkmj37t2aPHly7GiDjhIGAACicne1trYqTVM1NDSouLhYa9eu1eLFi9X/Qb5hiRIGAACiuHr1qmpqahRCUGdnp5Ik0Z49ezRx4sTY0bKCEgYAALLG3XXs2DGlaarGxkYtWbJE69atU3Fx8bCeet0MJQwAAGTclStXVF1drRCCenp6VF5erqeffloTJkyIHS0aShgAAMgId1dLS4tCCGpqatKyZcu0fv16LViwIO+mXjdDCQMAAIOqo6ND1dXVStNUZqby8nI988wzGj9+fOxoOYUSBgAA7pu768iRIwohqLm5WSUlJfrMZz6j+fPnM/W6BUoYAAC4Z5cvX1ZVVZVCCCooKFCSJFq/fr3GjRsXO1rOo4QBAIC74u46dOiQQgg6dOiQSkpK9OKLL2ru3LlMve4CJQwAAAxIe3v79anX2LFjlSSJNm7cqLFjx8aONiRRwgAAwC319vbq4MGDCiHoyJEjWrlypbZs2aLZs2cz9bpPlDAAAPAxFy9eVGVlpSorKzVhwgQlSaIXXnhBY8aMiR1t2KCEAQAASX1Tr+bmZoUQ1NLSotLSUm3dulWzZ8+OHW1YooQBAJDn2traFEJQZWWlpkyZoiRJtHnzZo0ePTp2tGGNEgYAQB7q6elRc3Oz0jTV8ePHVVpaqtdff10zZ86MHS1vUMIAAMgj58+fVwhBVVVVmj59upIk0SuvvKJRo0bFjpZ3KGEAAAxzPT09ampqUpqmOnnypB5++GFt27ZNM2bMiB0tr1HCAAAYps6dO6c0TVVdXa3CwkKVl5drxYoVKijg7T8XsBcAABhGuru71djYqBCCTp06pdWrV2v79u0qLCyMHQ0fQQkDAGAYOHv2rEIIqq6u1syZM1VeXq7ly5cz9cph7BkAAIaorq4uNTQ0KISgs2fPas2aNdqxY4emT58eOxoGgBIGAMAQc/r0aYUQVFNTozlz5uiRRx7R8uXLNXLkyNjRcBcoYQAADAFdXV2qr69XCEEXLlzQmjVrtHPnTk2dOjV2NNwjShgAADns5MmTCiGorq5O8+bN02OPPaZly5ZpxIgRsaPhPlHCAADIMZ2dnaqrq1MIQe3t7SorK9OuXbs0ZcqU2NEwiChhAADkiBMnTihNU9XX12vBggV64okntGTJEqZewxQlDACAiK5du6ba2lqFENTR0aEkSbR7925Nnjw5djRkGCUMAIAsc3e1trYqTVM1NDSouLhYa9eu1aJFi5h65RFKGAAAWXL16lXV1tYqTVN1dnYqSRLt2bNHEydOjB0NEVDCAADIIHfXsWPHFEJQQ0ODlixZonXr1qm4uFhmFjseIqKEAQCQAVeuXFFNTY3SNFVPT4+SJNFXvvIVTZgwIXY05AhKGAAAg8Td1dLSohCCmpqatHTpUq1fv14LFixg6oWPoYQBAHCfOjo6VF1drRCCJClJEj3zzDMaP3585GTIZZQwAADugbvryJEjCiGoublZy5cv18aNGzV//nymXhgQShgAAHfh8uXLqqqqUghBBQUFSpJE69ev17hx42JHwxBDCQMA4A7cXYcOHVIIQQcPHtSKFSv04osvau7cuUy9cM8oYQAA3MKlS5dUWVmpEILGjBmj8vJybdy4UWPHjo0dDcMAJQwAgBv09vbq0KFDStNUR44c0cqVK/Xyyy9rzpw5TL0wqDJWwszstyVtkHTa3Uv7l02X9P9KWijpiKRX3P18pjIAADBQFy9eVGVlpSorKzV+/HiVl5frhRde0JgxY2JHwzCVyUnYu5L+jaTfuWHZ1yT9F3f/eTP7Wv/jn8pgBgAAbqm3t1cHDhxQmqZqaWnRQw89pK1bt2r27NmxoyEPZKyEufvfmNnCjyzeJOnJ/q//g6S/FiUMAJBlbW1t16dekyZNUnl5uTZv3qzRo0fHjoY8ku1zwma6+wlJcvcTZvZglrcPAMhTPT09am5uVghBx44dU2lpqT772c9q5syZsaMhT+XsiflmtlPSTkkqKiqKnAYAMFSdP3/++tRr2rRpSpJEW7Zs0ahRo2JHQ57Ldgk7ZWaz+6dgsyWdvtWK7v6OpHckqaKiwrMVEAAw9PX09KipqUkhBLW2tmrVqlX63Oc+pwcf5AAMcke2S9h3JX1e0s/3//7HWd4+AGAYO3funEIIqqqqUmFhoZIk0auvvqqCgpw98IM8lslLVHxLfSfhF5rZMUnfUF/5+n0z2yGpRdKWTG0fAJAfuru71djYqBCCTp06pdWrV2v79u0qLCyMHQ24rUx+OvK1Wzz16UxtEwCQP86ePasQgqqrqzVz5kwlSaKSkhKmXhgy+JMKABgyuru7tW/fPoUQdPbsWa1Zs0Y7duzQ9OnTY0cD7holDACQ806fPq0QgmpqajRnzhw98sgjWr58uUaOHBk7GnDPKGEAgJzU1dWlffv2KU1TnT9/XmVlZfrSl76kadOmxY4GDApKGAAgp5w6dUppmqqurk7z5s3TY489pmXLlmnEiBGxowGDihIGAIius7NT9fX1StNU7e3tKisr065duzRlypTY0YCMoYQBAKI5ceKE0jRVfX29ioqK9MQTT2jJkiVMvZAXKGEAgKy6du2a6urqlKapOjo6VFZWpt27d2vy5MmxowFZRQkDAGScu6u1tVVpmqqhoUELFy7U2rVrtWjRIqZeyFuUMABAxly9elW1tbUKIejq1atKkkRvv/22Jk2aFDsaEB0lDAAwqNxdx44dUwhBjY2NWrRokZ5++mkVFxfLzGLHA3IGJQwAMCiuXLmimpoahRDU3d2tJEn05S9/WRMmTIgdDchJlDAAwD1zd33wwQdK01RNTU1aunSpnn32WS1cuJCpF3AHlDAAwF3r6OhQdXW1QgiSpCRJ9Mwzz2j8+PGRkwFDByUMADAg7q6jR48qTVM1Nzdr+fLl2rBhg4qKiph6AfeAEgYAuK3Lly+rqqpKIQSNHDlS5eXlWr9+vcaNGxc7GjCkUcIAAB/j7jp8+LBCCDp48KBKSkr0wgsvaN68eUy9gEFCCQMAXHfp0iVVVlaqsrJSo0ePVnl5uTZs2KCxY8fGjgYMO5QwAMhz7q6DBw8qhKDDhw9rxYoV2rx5s+bMmcPUC8ggShgA5KmLFy9eP9dr/PjxKi8v16ZNmzRmzJjY0YC8QAkDgDzS29urAwcOKISgo0eP6qGHHtLWrVs1e/bs2NGAvEMJA4A80NbWdv1cr0mTJilJEr300ksaPXp07GhA3qKEAcAw1dvbq/379yuEoGPHjqm0tFSvvfaaZs2aFTsaAFHCAGDYuXDhgkIIqqqq0tSpU5UkibZs2aJRo0bFjgbgBpQwABgGenp61NTUpBCCWltbtWrVKr3xxht68MEHY0cDcAuUMAAYws6dO3d96lVYWKgkSbR161amXsAQQAkDgCGmu7tbTU1NStNUp06d0urVq7V9+3YVFhbGjgbgLlDCAGCI+PDDD5WmqaqrqzVz5kwlSaKSkhIVFPBXOTAU8ZMLADmsu7tbDQ0NStNUZ8+e1erVq/WFL3xBDzzwQOxoAO4TJQwActCZM2eUpqlqa2s1e/ZsPfLII1q+fLlGjhwZOxqAQUIJA4Ac0dXVpX379ilNU50/f15r1qzRF7/4RU2bNi12NAAZQAkDgMhOnTqlNE1VV1enuXPn6rHHHtPSpUuZegHDHCUMACLo7OxUfX29Qghqa2tTWVmZdu7cqalTp8aOBiBLKGEAkEUnTpxQCEF1dXUqKirSJz/5SS1ZskQjRoyIHQ1AllHCACDDrl27prq6OoUQdPnyZZWVlWn37t2aPHly7GgAIqKEAUAGuLtOnDihNE21b98+LVy4UE8++aQWL17M1AuAJEoYAAyqq1evqra2ViEEXb16VUmS6O2339akSZNiRwOQYyhhAHCf3F3Hjx9XmqZqbGzUokWL9NRTT2nRokUys9jxAOQoShgA3KMrV66opqZGIQR1d3crSRLt2bNHEydOjB0NwBBACQOAu+Du+uCDDxRCUGNjo5YuXapnn31WCxcuZOoF4K5QwgBgADo6OlRTU6M0TeXuKi8v17p16zR+/PjY0QAMUZQwALgFd9fRo0cVQtD+/fu1fPlybdiwQUVFRUy9ANy3KCXMzH5S0hcluaRaSW+6+9UYWQDgoy5fvqzq6mqFEDRixAglSaLnnntO48aNix0NwDCS9RJmZnMl/bikle5+xcx+X9Krkt7NdhYA+CF31+HDhxVC0IEDB1RSUqJNmzZp3rx5TL0AZESsw5EFksaZWZek8ZJaI+UAkOcuXbqkqqoqhRA0evRoJUmiDRs2aOzYsbGjARjmsl7C3P24mf0rSS2Srkj6C3f/i2znAJC/3F0HDx5UCEGHDx/WihUrtHnzZs2ZM4epF4CsiXE4cpqkTZKKJV2Q9J/N7A13/48fWW+npJ2SVFRUlO2YAIah9vZ2VVZWqrKyUuPGjVOSJNq0aZPGjBkTOxqAPBTjcORTkg67+xlJMrPvSHpM0o+UMHd/R9I7klRRUeHZDglgeOjt7dWBAwcUQtDRo0f10EMPacuWLZozZ07saADyXIwS1iLpUTMbr77DkZ+WtDdCDgDDWFtb2/Wp16RJk5QkiV566SWNHj06djQAkBTnnLAfmNkfSAqSuiVVqn/iBQD3o7e3V83NzUrTVB988IFKS0v12muvadasWbGjAcDHRPl0pLt/Q9I3YmwbwPBz4cIFhRBUVVWlqVOnKkkSvfzyy0y9AOQ0rpgPYEjq6enR/v37laapWltb9fDDD+uNN97Qgw8+GDsaAAwIJQzAkHLu3DmFEFRdXa3p06ervLxcW7du1ahRo2JHA4C7QgkDkPN6enrU2NioEIJOnjypVatWadu2bZoxY0bsaABwzyhhAHLWhx9+eH3qNWPGDJWXl6ukpEQFBfzVBWDo428yADmlu7tbDQ0NCiHozJkzWr16td5880098MADsaMBwKCihAHICWfOnFEIQTU1NZo1a5YqKipUUlKikSNHxo4GABlBCQMQTVdXl/bt26cQgs6dO6c1a9boi1/8oqZNmxY7GgBkHCUMQNadOnVKIQTV1tZq7ty5evTRR7Vs2TKmXgDyCiUMQFZ0dnaqvr5eIQS1tbWprKxMO3fu1NSpU2NHA4AoKGEAMurkyZNK01T19fWaP3++Hn/8cS1dulQjRoyIHQ0AoqKEARh0165dU11dnUIIunTpkpIk0VtvvaXJkyfHjgYAOYMSBmDQtLa2Kk1T7du3TwsXLtSTTz6pxYsXM/UCgJughAG4L9euXVNtba3SNNXVq1eVJInefvttTZo0KXY0AMhplDAAd83ddfz4caVpqsbGRi1atEhPPfWUFi1aJDOLHQ8AhgRKGIABu3r1qmpqapSmqbq6upQkifbs2aOJEyfGjgYAQ86ASpiZLZZ0zN2vmdmTklZJ+h13v5DJcADic3d98MEHCiGosbFRS5Ys0bPPPquFCxcy9QKA+zDQSdi3JVWY2RJJ35T0XUm/J2l9poIBiKujo0M1NTUKIai3t1dJkujpp5/WhAkTYkcDgGFhoCWs1927zexFSb/s7r9qZpWZDAYg+9xdR48eVQhB+/fv17Jly/T888+rqKiIqRcADLKBlrAuM3tN0uclbexfNiozkQBk2+XLl1VdXa0QgkaMGKEkSfTcc89p3LhxsaMBwLA10BL2pqS3JP1zdz9sZsWS/mPmYgHINHfX4cOHFULQgQMHVFJSok2bNmnevHlMvQAgCwZUwtx9n6Qfv+HxYUk/n6lQADLn0qVLqqqqUghBo0aNUnl5uZ5//nmmXgCQZQP9dOQnJP2spAX932OS3N0XZS4agMHi7jp06JDSNNXhw4e1YsUKvfTSS5o7dy5TLwCIZKCHI78p6SclpZJ6MhcHwGBqb29XZWWlKisrNXbsWJWXl2vTpk0aM2ZM7GgAkPcGWsLa3P3PMpoEwKDo7e3VwYMHlaapjh49qpUrV2rLli2aM2dO7GgAgBsMtIT9lZn9gqTvSLr2w4XuHjKSCsBda2truz71mjhxosrLy/XSSy9p9OjRsaMBAG5ioCXs7/X/XnHDMpe0dnDjALgbvb29am5uVghBLS0tKi0t1WuvvaZZs2bFjgYAuIOBfjry72c6CICBu3DhwvWp15QpU5QkiTZv3szUCwCGkIF+OvIf3GRxm6TU3asGNxKAm+np6dH+/fsVQtDx48f18MMP64033tCDDz4YOxoA4B4M9HBkRf+v7/U/fl7S/5T0lpn9Z3f/vzIRDoB0/vx5hRBUVVWl6dOnK0kSvfLKKxo1iptWAMBQNtAS9oCkxN0vSZKZfUPSH0h6Qn2XraCEAYOop6dHjY2NCiHo5MmTWrVqlbZt26YZM2bEjgYAGCQDLWFFkjpveNwlaYG7XzGza7f4HgB36cMPP1QIQdXV1ZoxY4aSJNGKFStUUDDQH1UAwFAx0L/Zf0/S+2b2x/2PN0r6lplNkLQvI8mAPNHd3a2GhgaFEHTmzBmtXr1ab775ph544IHY0QAAGTTQT0f+nJn9qaTH1XfLorfcfW//069nKhwwnJ05c0YhBNXU1GjWrFmqqKhQSUmJRo4cGTsaACALblvCzGyyu180s+mSDvf/+uFz0939XKYDAsNJV1eXGhoalKapzp07pzVr1mjHjh2aPn167GgAgCy70yTs9yRtUN/J937Dcut/zA28gQE4ffq00jRVbW2t5s6dq0cffVTLli1j6gUAeey2JczdN/T/XpydOMDw0dXVpfr6eqVpqra2NpWVlWnnzp2aOnVq7GgAgBww0Iu1fkJSlbtfNrM3JCWSftndWzKaDhiCTp48qTRNVVdXp6KiIj3++ONaunSpRowYETsaACCHDPTTkb8uabWZrZb0jyR9U9L/I+lTmQoGDCWdnZ2qq6tTmqa6dOmSysrK9NZbb2nKlCmxowEActRAS1i3u7uZbZL0K+7+TTP7fCaDAUNBa2ur0jTVvn37tGDBAj355JNavHgxUy8AwB0NtIS1m9lPS/qcpE+a2UhJ3DMFeenatWuqra1VCEEdHR1KkkRvv/22Jk2aFDsaAGAIGWgJ2yrps5K+4O4nzaxI0i9kLhaQW9xdx48fVwhBDQ0NKi4u1qc//WktWrRIZhY7HgBgCBroxVpPmtm3JS3tX3RW0h/e60bNbKqk35JUqr5LXXzB3b9/r68HZMrVq1dVU1OjEII6OzuVJIn27NmjiRMnxo4GABjiBvrpyC9J2ilpuqTFkuZK+g1Jn77H7f6KpD9395fNbLSk8ff4OsCgc3cdO3ZMaZqqsbFRS5Ys0bp161RcXMzUCwAwaAZ6OHKPpEck/UCS3L3ZzB68lw2a2WRJT0ja3v9anfrRm4MDUVy5ckXV1dUKIai3t1dJkujpp5/WhAkTYkcDAAxDAy1h19y984dTADMr0I9eQf9uLJJ0RtK/77/kRSrpq+5++R5fD7hn7q6Wlhalaar9+/dr2bJlWr9+vRYsWMDUCwCQUQMtYf/NzP6xpHFm9rSktyV97z62mUj6irv/wMx+RdLXJP2fN65kZjvVdwhURUVF97gp4OY6OjpUVVWlEILMTOXl5Xr22Wc1fjxHxgEA2WHudx5omdkISTskrVPffSPfk/RbPpBv/vhrzZL0vrsv7H/8SUlfc/fnb/U9FRUVvnfv3rvdFPAj3F1HjhxRCEHNzc0qKSlRkiSaP38+Uy8AwKAxs9TdK+603kA/HdlrZn8k6Y/c/cz9BOv/pOUHZrbc3ZvUd3L/vvt5TeB2Ll26pKqqKlVWVqqgoEDl5eVav369xo0bFzsaACCP3baEWd944BuSvqy+CZiZWY+kX3X3f3of2/2KpN/t/2TkIUlv3sdrAR/j7jp06JBCCDp06JBKSkr04osvau7cuUy9AAA54U6TsJ+Q9AlJP+buhyXJzBZJ+nUz+0l3/6V72ai7V0m645gOuFvt7e3Xz/UaO3asysvLtXHjRo0dOzZ2NAAAfsSdStg2SU+7+9kfLnD3Q2b2hqS/kHRPJQwYTL29vTp48KBCCDpy5IhWrlypLVu2aPbs2Uy9AAA5604lbNSNBeyH3P2MmXHvSER18eJFVVZWqrKyUhMmTFCSJHrhhRc0ZsyY2NEAALijO5Ww211ElQusIut6e3vV3NysEIJaWlpUWlqqrVu3avbs2bGjAQBwV+5Uwlab2cWbLDdJnGSDrLlw4cL1qdeUKVOUJIk2b96s0aNHx44GAMA9uW0Jc/eR2QoCfFRPT4/279+vEIKOHz+uhx9+WK+//rpmzpwZOxoAAPdtoFfMB7Lm/PnzCiGoqqpK06dPV5IkeuWVVzRqFKchAgCGD0oYckJPT4+ampqUpqlOnjypVatWadu2bZoxY0bsaAAAZAQlDFF9+OGHCiGourpaM2bMUJIkWrFihQoK+KMJABjeeKdD1nV3d6uxsVFpmurMmTNatWqVtm/frsLCwtjRAADIGkoYsubs2bNK01Q1NTWaNWuWKioqtHz5cqZeAIC8xLsfMqqrq0sNDQ1K01Qffvih1qxZox07dmj69OmxowEAEBUlDBlx+vRppWmq2tpazZkzR48++qiWLVumkSO56gkAABIlDIOoq6tL9fX1CiHowoULWrNmjXbu3KmpU6fGjgYAQM6hhOG+nTx5UiEE1dXVad68efrEJz6hpUuXasSIEbGjAQCQsyhhuCednZ2qq6tTCEHt7e0qKyvTrl27NGXKlNjRAAAYEihhuCsnTpxQmqaqr6/XggUL9MQTT2jJkiVMvQAAuEuUMNzRtWvXVFtbqxCCOjo6lCSJdu/ercmTJ8eOBgDAkEUJw025u1pbW5WmqRoaGlRcXKy1a9dq0aJFTL0AABgElDD8iKtXr6qmpkYhBHV2dipJEu3Zs0cTJ06MHQ0AgGGFEga5u44dO6YQghoaGrRkyRKtW7dOxcXFMrPY8QAAGJYoYXnsypUrqqmpUZqm6unpUXl5uZ566ilNmDAhdjQAAIY9SliecXe1tLQohKCmpiYtW7ZM69ev14IFC5h6AQCQRZSwPNHR0aHq6mqFECRJSZLomWee0fjx4yMnAwAgP1HChjF315EjRxRCUHNzs5YvX66NGzdq/vz5TL0AAIiMEjYMXb58WVVVVQohqKCgQEmSaP369Ro3blzsaAAAoB8lbJhwdx06dEghBB08eFArVqzQiy++qLlz5zL1AgAgB1HChrj29vbrU6+xY8cqSRJt3LhRY8eOjR0NAADcBiVsCOrt7dXBgwcVQtCRI0e0cuVKbdmyRbNnz2bqBQDAEEEJG0IuXryoyspKVVZWasKECUqSRC+88ILGjBkTOxoAALhLlLAc19vbq+bmZoUQ1NLSotLSUm3dulWzZ8+OHQ0AANwHSliOamtrUwhBlZWVmjJlipIk0ebNmzV69OjY0QAAwCCghOWQnp4eNTc3K01THT9+XKWlpXr99dc1c+bM2NEAAMAgo4TlgPPnzyuEoKqqKk2bNk3l5eV65ZVXNGrUqNjRAABAhlDCIunp6VFTU5NCCGptbdWqVau0bds2zZgxI3Y0AACQBZSwLDt37tz1qVdhYaHKy8v16quvqqCAXQEAQD7hnT8Luru71djYqBCCTp06pdWrV2v79u0qLCyMHQ0AAERCCcugs2fPKoSg6upqzZw5U0mSqKSkhKkXAACghA227u5u7du3TyEEnT17VmvWrNGOHTs0ffr02NEAAEAOoYQNktOnTyuEoJqaGs2ZM0ePPPKIli9frpEjR8aOBgAAchAl7D50dXWpvr5XuDoFAAAK/UlEQVReIQSdP39eZWVl+tKXvqRp06bFjgYAAHIcJewenDp1Smmaqq6uTvPmzdNjjz2mZcuWacSIEbGjAQCAIYISNkCdnZ2qq6tTCEHt7e0qKyvTrl27NGXKlNjRAADAEBSthJnZSEl7JR139w2xctzJiRMnlKap6uvrtWDBAj3xxBNasmQJUy8AAHBfYk7CviqpQdLkiBlu6tq1a6qrq1Oapuro6FCSJNq9e7cmT865qAAAYIiKUsLMbJ6k5yX9c0n/IEaGj9qzZ4+++93v6vXXX9e0adNUXFystWvXatGiRUy9AADAoIs1CftlSf9I0qRbrWBmOyXtlKSioqKMB3rvvff00ksv6fvf/77+5E/+RJMm3TIaAADAfcv6iMfMNkg67e7p7dZz93fcvcLdK7JxU+tnnnlGv/Zrv6bS0lIKGAAAyDhz9+xu0OxfSPqcpG5JY9V3Tth33P2NW31PRUWF7927N0sJAQAA7p2Zpe5ecaf1sj4Jc/efdvd57r5Q0quS/uvtChgAAMBwxBnnAAAAEUS9WKu7/7Wkv46ZAQAAIAYmYQAAABFQwgAAACKghAEAAERACQMAAIiAEgYAABABJQwAACACShgAAEAElDAAAIAIKGEAAAARUMIAAAAioIQBAABEQAkDAACIgBIGAAAQASUMAAAgAkoYAABABJQwAACACChhAAAAEVDCAAAAIqCEAQAAREAJAwAAiIASBgAAEAElDAAAIAJKGAAAQASUMAAAgAgoYQAAABFQwgAAACKghAEAAERACQMAAIiAEgYAABABJQwAACACShgAAEAElDAAAIAIKGEAAAARUMIAAAAioIQBAABEQAkDAACIgBIGAAAQASUMAAAgAkoYAABABJQwAACACChhAAAAEWS9hJnZfDP7KzNrMLN6M/tqtjMAAADEVhBhm92S/qG7BzObJCk1s790930RsgAAAESR9UmYu59w99D/dbukBklzs50DAAAgpqjnhJnZQkllkn4QMwcAAEC2RSthZjZR0rcl/YS7X7zJ8zvNbK+Z7T1z5kz2AwIAAGRQlBJmZqPUV8B+192/c7N13P0dd69w94oZM2ZkNyAAAECGxfh0pEn6pqQGd//FbG8fAAAgF8SYhH1C0uckrTWzqv5f6yPkAAAAiCbrl6hw9/8uybK9XQAAgFzCFfMBAAAioIQBAABEQAkDAACIgBIGAAAQASUMAAAgAkoYAABABJQwAACACChhAAAAEVDCAAAAIqCEAQAAREAJAwAAiIASBgAAEAElDAAAIAJKGAAAQASUMAAAgAgoYQAAABFQwgAAACKghAEAAERACQMAAIiAEgYAABABJQwAACACShgAAEAElDAAAIAIKGEAAAARUMIAAAAioIQBAABEQAkDAACIgBIGAAAQASUMAAAgAkoYAABABJQwAACACChhAAAAEVDCAAAAIqCEAQAAREAJAwAAiIASBgAAEAElDAAAIAJKGAAAQASUMAAAgAgoYQAAABFQwgAAACKIUsLM7FkzazKzA2b2tRgZAAAAYsp6CTOzkZJ+TdJzklZKes3MVmY7BwAAQEwxJmGPSDrg7ofcvVPSf5K0KUIOAACAaGKUsLmSPrjh8bH+ZQAAAHmjIMI27SbL/GMrme2UtLP/4SUza8poqj6Fks5mYTsYOPZJ7mGf5B72SW5iv+SebO2TBQNZKUYJOyZp/g2P50lq/ehK7v6OpHeyFUqSzGyvu1dkc5u4PfZJ7mGf5B72SW5iv+SeXNsnMQ5H/k9JS82s2MxGS3pV0ncj5AAAAIgm65Mwd+82sy9Lek/SSEm/7e712c4BAAAQU4zDkXL3P5X0pzG2fQdZPfyJAWGf5B72Se5hn+Qm9kvuyal9Yu4fOyceAAAAGcZtiwAAACLIuxJmZr9tZqfNrO4Wz5uZ/ev+WyrVmFmS7Yz5ZgD75PX+fVFjZv/DzFZnO2M+utN+uWG9HzOzHjN7OVvZ8tVA9omZPWlmVWZWb2b/LZv58tEA/v6aYmbfM7Pq/n3yZrYz5hMzm29mf2VmDf3/v796k3Vy5n0+70qYpHclPXub55+TtLT/105Jv56FTPnuXd1+nxyW9Cl3XyXp55Rjx/SHsXd1+/3yw9uQ/Uv1fdAGmfeubrNPzGyqpH8r6TPu/pCkLVnKlc/e1e1/TvZI2ufuqyU9Ken/7r8yADKjW9I/dPcVkh6VtOcmt0bMmff5vCth7v43ks7dZpVNkn7H+7wvaaqZzc5Ouvx0p33i7v/D3c/3P3xffdeWQ4YN4GdFkr4i6duSTmc+EQawTz4r6Tvu3tK/PvslwwawT1zSJDMzSRP71+3ORrZ85O4n3D30f90uqUEfvytPzrzP510JGwBuq5Tbdkj6s9ghIJnZXEkvSvqN2Flw3TJJ08zsr80sNbNtsQNB/0bSCvVdlLxW0lfdvTdupPxgZgsllUn6wUeeypn3+SiXqMhxA7qtErLPzP6++krY47GzQJL0y5J+yt17+v6RjxxQIKlc0qcljZP0fTN73933x42V156RVCVpraTFkv7SzP7W3S/GjTW8mdlE9U3pf+Im/69z5n2eEvZxA7qtErLLzFZJ+i1Jz7n7h7HzQJJUIek/9RewQknrzazb3f8obqy8dkzSWXe/LOmymf2NpNWSKGHxvCnp573velAHzOywpBJJfxc31vBlZqPUV8B+192/c5NVcuZ9nsORH/ddSdv6Pz3xqKQ2dz8RO1Q+M7MiSd+R9Dn+RZ873L3Y3Re6+0JJfyDpbQpYdH8s6ZNmVmBm4yX9PfWdE4N4WtQ3mZSZzZS0XNKhqImGsf5z774pqcHdf/EWq+XM+3zeTcLM7Fvq+4RKoZkdk/QNSaMkyd1/Q31X8l8v6YCkDvX9KwYZNIB98jOSHpD0b/unLt25dAPW4WoA+wVZdqd94u4NZvbnkmok9Ur6LXe/7SVGcH8G8HPyc5LeNbNa9R0G+yl3Pxspbj74hKTPSao1s6r+Zf9YUpGUe+/zXDEfAAAgAg5HAgAAREAJAwAAiIASBgAAEAElDAAAIAJKGAAAQAR5d4kKAMOHmT0g6b/0P5wlqUfSmf7Hj7h7Zwa2mUh60N3/fLBfG0B+oYQBGLL6756wRpLM7GclXXL3fzXQ7zezke7ec5ebTSSVSqKEAbgvHI4EMCyZ2ff6b2Jdb2Zf7F9WYGYXzOyfmdnfSXrEzD5jZk1m9rdm9qtm9kf96040s3fN7O/MrNLMNprZOPVdPPh1M6sys5cj/icCGOKYhAEYrj7v7uf6b9+z18y+Lald0hRJwd3/j/7n9qvvKtstkn7/hu//GUl/7u7bzWyapB9IWiXpn0oqdfefyOZ/DIDhh0kYgOHqJ82sWtL31XeD3sX9yzsl/WH/1yslNbn70f4bLH/rhu9fJ+nr/bc++StJY9V/6xMAGAxMwgAMO2b2lKQnJD3q7lfM7L+rr0RJ0hX/3/drs9u9jKQX3P3gR177iUEPDCAvMQkDMBxNkXSuv4A9JOnHbrFevaTlZjbf+u4Ov/WG596T9OM/fGBmZf1ftkualIHMAPIMJQzAcPT/SRrffzjyZ9R3PtfHuHuHpC9L+v8l/a2kVklt/U//k/7XqDWzekk/27/8v0pa3X+yPifmA7hn9r+n8gCQf8xsortf6p+E/aakWnf/1di5AAx/TMIA5Lvd/Sff75M0TtK/i5wHQJ5gEgYAABABkzAAAIAIKGEAAAARUMIAAAAioIQBAABEQAkDAACIgBIGAAAQwf8CM+dmlybdhkgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Save results as CSV file? EXIT\n"
     ]
    },
    {
     "ename": "SystemExit",
     "evalue": "0",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[1;31mSystemExit\u001b[0m\u001b[1;31m:\u001b[0m 0\n"
     ]
    }
   ],
   "source": [
    "# DESIGN PERMUTATIONS\n",
    "\n",
    "# Begin\n",
    "newAnalysis = 'yes'\n",
    "while newAnalysis == 'yes':\n",
    "\n",
    "    # TALENs or DdCBEs?\n",
    "    design = 0\n",
    "    while design == 0:\n",
    "        design = input('\\nDesign:\\nA. TALENs\\nB. DdCBEs (DddA)\\nC. DdCBEs (DddA11)\\n')\n",
    "        if design.lower() == 'exit': sys.exit(0)\n",
    "        if design not in {'A','a','B','b', 'C','c'}:\n",
    "            design = 0\n",
    "            print('Invalid input! Choose A, B or C.')\n",
    "        else: design = design.lower()  \n",
    "\n",
    "    # TALENs for what?\n",
    "    if design == 'a':\n",
    "        TALENfor = 0 \n",
    "        while TALENfor == 0:\n",
    "            TALENfor = input('\\nFind TALEN pairs for:\\nA. All potential targets\\nB. Specific site\\n')\n",
    "            if TALENfor.lower() == 'exit': sys.exit(0)\n",
    "            if TALENfor not in {'A','a','B','b'}:\n",
    "                TALENfor = 0\n",
    "                print('Invalid input! Choose A or B.')\n",
    "            else: TALENfor = TALENfor.lower()\n",
    "\n",
    "    # DdCBEs for what?\n",
    "    else:\n",
    "        BEfor = 0\n",
    "        while BEfor == 0:\n",
    "            BEfor = input(\"\\nBase editors for:\\nA. All potential targets\\nB. Specific site\\nC. PTCs\\n\")\n",
    "            if BEfor.lower() == 'exit': sys.exit(0)\n",
    "            if BEfor not in {'A','a','B','b','C','c'}:\n",
    "                BEfor = 0\n",
    "                print('Invalid input! Choose A, B or C.')\n",
    "            else: BEfor = BEfor.lower()\n",
    "\n",
    "    # Design parameters\n",
    "    default = 0\n",
    "    while default == 0:\n",
    "        default = input('\\nUse default design parameters? ')\n",
    "        if default.lower() == 'exit': sys.exit(0)\n",
    "        if default.lower() not in {'yes','y','no','n'}:\n",
    "            default = 0\n",
    "            print(\"Invalid input! Type 'yes' or 'no'\")     \n",
    "    # Default paramaters\n",
    "    if default.lower() in {'yes','y'}:\n",
    "        leftArmMin, spacerMin, rightArmMin, leftArm5 = 15,14,15, True\n",
    "        leftArmMax, spacerMax, rightArmMax, rightArm5 = 16,16,16, True\n",
    "        targetWindow = 4\n",
    "        print('\\nLeft arm minimum length (bp): 15\\nLeft arm maximum length (bp): 16\\n'\\\n",
    "              \"Left 5'-T constraint: Yes\\n\"\\\n",
    "              '\\nSpacer minimum length (bp): 14\\nSpacer maximum length (bp): 16\\n'\\\n",
    "              '\\nRight arm minimum length (bp): 15\\nRight arm maximum length (bp): 16\\n'\\\n",
    "              \"Right 5'-T constraint: Yes\\n\"\\\n",
    "              '\\nTarget window: 4')\n",
    "    # Custom parameters\n",
    "    else:\n",
    "        # Left arm minimum length\n",
    "        leftArmMin = 0\n",
    "        while leftArmMin == 0:\n",
    "            leftArmMin = input('\\nLeft arm minimum length (bp): ')\n",
    "            if leftArmMin.lower() == 'exit': sys.exit(0)\n",
    "            try:\n",
    "                leftArmMin = int(leftArmMin)\n",
    "                if leftArmMin < 5 or leftArmMin > 25:\n",
    "                    leftArmMin = 0\n",
    "                    print('Invalid input! Minimum length must be an integer between 5 and 25.')\n",
    "            except:\n",
    "                leftArmMin = 0\n",
    "                print('Invalid input! Minimum length must be an integer between 5 and 25.')\n",
    "        # Left arm maximum length\n",
    "        leftArmMax = 0\n",
    "        while leftArmMax == 0:\n",
    "            leftArmMax = input('\\nLeft arm maximum length (bp): ')\n",
    "            if leftArmMax.lower() == 'exit': sys.exit(0)\n",
    "            try:\n",
    "                leftArmMax = int(leftArmMax)\n",
    "                if leftArmMax < 5 or leftArmMax > 25:\n",
    "                    leftArmMax = 0\n",
    "                    print('Invalid input! Maximum length must be an integer between 5 and 25.')\n",
    "                elif leftArmMax < leftArmMin:\n",
    "                    leftArmMax = 0\n",
    "                    print('Invalid input! Maximum length cannot be less than minimum length.')\n",
    "            except:\n",
    "                leftArmMax = 0\n",
    "                print('Invalid input! Maximum length must be an integer between 5 and 25.')\n",
    "        # Left arm 5'-T constraint\n",
    "        leftArm5 = 2\n",
    "        while leftArm5 == 2:\n",
    "            leftArm5 = input(\"\\nLeft 5'-T constraint? \")\n",
    "            if leftArm5.lower() == 'exit': sys.exit(0)\n",
    "            if leftArm5.lower() not in {'yes','y','no','n'}:\n",
    "                leftArm5 = 2\n",
    "                print(\"Invalid input! Type 'yes' or 'no'\")\n",
    "            elif leftArm5.lower() in {'yes','y'}: leftArm5 = True\n",
    "            elif leftArm5.lower() in {'no','n'}: leftArm5 = False\n",
    "        # Spacer minimum length\n",
    "        spacerMin = 0\n",
    "        while spacerMin == 0:\n",
    "            spacerMin = input('\\nSpacer minimum length (bp): ')\n",
    "            if spacerMin.lower() == 'exit': sys.exit(0)\n",
    "            try:\n",
    "                spacerMin = int(spacerMin)\n",
    "                if spacerMin < 5 or spacerMin > 25:\n",
    "                    spacerMin = 0\n",
    "                    print('Invalid input! Minimum length must be an integer between 5 and 25.')\n",
    "            except:\n",
    "                spacerMin = 0\n",
    "                print('Invalid input! Minimum length must be an integer between 5 and 25.')\n",
    "        # Spacer maximum length\n",
    "        spacerMax = 0\n",
    "        while spacerMax == 0:\n",
    "            spacerMax = input('\\nSpacer maximum length (bp): ')\n",
    "            if spacerMax.lower() == 'exit': sys.exit(0)\n",
    "            try:\n",
    "                spacerMax = int(spacerMax)\n",
    "                if spacerMax < 5 or spacerMax > 25:\n",
    "                    spacerMax = 0\n",
    "                    print('Invalid input! Maximum length must be an integer between 5 and 25.')\n",
    "                elif spacerMax < spacerMin:\n",
    "                    spacerMax = 0\n",
    "                    print('Invalid input! Maximum length cannot be less than minimum length.')\n",
    "            except:\n",
    "                spacerMax = 0\n",
    "                print('Invalid input! Maximum length must be an integer between 5 and 25.')\n",
    "        # Right arm minimum length\n",
    "        rightArmMin = 0\n",
    "        while rightArmMin == 0:\n",
    "            rightArmMin = input('\\nRight arm minimum length (bp): ')\n",
    "            if rightArmMin.lower() == 'exit': sys.exit(0)\n",
    "            try:\n",
    "                rightArmMin = int(rightArmMin)\n",
    "                if rightArmMin < 5 or rightArmMin > 25:\n",
    "                    rightArmMin = 0\n",
    "                    print('Invalid input! Minimum length must be an integer between 5 and 25.')\n",
    "            except:\n",
    "                rightArmMin = 0\n",
    "                print('Invalid input! Minimum length must be an integer between 5 and 25.')\n",
    "        # Right arm maximum length\n",
    "        rightArmMax = 0\n",
    "        while rightArmMax == 0:\n",
    "            rightArmMax = input('\\nRight arm maximum length (bp): ')\n",
    "            if rightArmMax.lower() == 'exit': sys.exit(0)\n",
    "            try:\n",
    "                rightArmMax = int(rightArmMax)\n",
    "                if rightArmMax < 5 or rightArmMax > 25:\n",
    "                    rightArmMax = 0\n",
    "                    print('Invalid input! Maximum length must be an integer between 5 and 25.')\n",
    "                elif rightArmMax < rightArmMin:\n",
    "                    rightArmMax = 0\n",
    "                    print('Invalid input! Maximum length cannot be less than minimum length.')\n",
    "            except:\n",
    "                rightArmMax = 0\n",
    "                print('Invalid input! Maximum length must be an integer between 5 and 25.')\n",
    "        # Right arm 5'-T constraint\n",
    "        rightArm5 = 2\n",
    "        while rightArm5 == 2:\n",
    "            rightArm5 = input(\"\\nRight 5'-T constraint? \")\n",
    "            if rightArm5.lower() == 'exit': sys.exit(0)\n",
    "            if rightArm5.lower() not in {'yes','y','no','n'}:\n",
    "                rightArm5 = 2\n",
    "                print(\"Invalid input! Type 'yes' or 'no'\")\n",
    "            elif rightArm5.lower() in {'yes','y'}: rightArm5 = True\n",
    "            elif rightArm5.lower() in {'no','n'}: rightArm5 = False\n",
    "        # Target window\n",
    "        targetWindow = -1\n",
    "        while targetWindow == -1:\n",
    "            targetWindow = input('\\nTarget window: ')\n",
    "            if targetWindow.lower() == 'exit': sys.exit(0)\n",
    "            try:\n",
    "                targetWindow = int(targetWindow)\n",
    "                # If spacer length is even\n",
    "                if (spacerMax % 2) == 0:\n",
    "                    if targetWindow < 0 or targetWindow > ((spacerMax-2)/2):\n",
    "                        targetWindow = -1\n",
    "                        print('Invalid input! The target window cannot be less than 0 or greater than ' + str(int((spacerMax-2)/2)) + '.')\n",
    "                # If spacer length is odd\n",
    "                else:\n",
    "                    if targetWindow < 0 or targetWindow > ((spacerMax-1)/2):\n",
    "                        targetWindow = -1\n",
    "                        print('Invalid input! The target window cannot be less than 0 or greater than ' + str(int((spacerMax-1)/2)) + '.')\n",
    "            except:\n",
    "                targetWindow = -1\n",
    "                print('Invalid input! The target window must be a non-negative integer.')\n",
    "\n",
    "    # Begin design analysis\n",
    "    newSequence, count = True, 0\n",
    "    while newSequence == True:\n",
    "\n",
    "        # Analysis number\n",
    "        count += 1\n",
    "        print('')\n",
    "        print('-' * (13 + len(str(count))))\n",
    "        print('SEQUENCE NO. ' + str(count))\n",
    "        print('-' * (13 + len(str(count))))\n",
    "\n",
    "        # Define input\n",
    "        sequence = 0\n",
    "        while sequence == 0:\n",
    "            sequence = input(\"\\nSequence (5'-to-3'): \")\n",
    "            if sequence.lower() == 'exit': sys.exit(0)\n",
    "            x, i = sequence.lower(), 0\n",
    "            while i in range(0,int(len(x))):\n",
    "                if x[i] not in {'a','c','g','t'}:\n",
    "                    print('Invalid sequence!')\n",
    "                    i = len(sequence)\n",
    "                    sequence = 0\n",
    "                else: i += 1\n",
    "        sequence = sequence.lower() # To facilitate the analysis\n",
    "\n",
    "        # TALEN design\n",
    "        if design == 'a':\n",
    "            # All potential targets\n",
    "            if TALENfor == 'a':\n",
    "                coordinates = [[],[]]    \n",
    "                for i in range(0,len(sequence)-1):\n",
    "                    coordinates[0].append(sequence[i:i+2].upper())\n",
    "                    coordinates[1].append(i+1)   \n",
    "            # Specific site\n",
    "            elif TALENfor == 'b':\n",
    "                # Define the target\n",
    "                coordinate, coordinates = 0, [[],[]]\n",
    "                while coordinate == 0:\n",
    "                    coordinate = input('\\nTarget coordinate: ')\n",
    "                    if coordinate.lower() == 'exit': sys.exit(0)\n",
    "                    try:\n",
    "                        coordinate = int(coordinate)\n",
    "                        if coordinate <= 0:\n",
    "                            coordinate = 0\n",
    "                            print('Invalid input! The target coordinate must be a positive integer.')\n",
    "                        elif coordinate > len(sequence):\n",
    "                            coordinate = 0\n",
    "                            print('Invalid input! The target coordinate cannot be outside of the sequence of interest.')\n",
    "                        else:\n",
    "                            coordinates[0].append(sequence[coordinate-1:coordinate-1+2].upper())\n",
    "                            coordinates[1].append(coordinate)\n",
    "                    except ValueError:\n",
    "                        coordinate = 0\n",
    "                        print('Invalid input! The target coordinate must be a positive integer.')\n",
    "            proceed = True # No need to check for targets\n",
    "\n",
    "        # TC-to-TT DdCBE design\n",
    "        elif design == 'b':\n",
    "            coordinates, targetCount = [[],[]], 0\n",
    "            # TC motifs\n",
    "            if BEfor == 'a':\n",
    "                # Find all target sites\n",
    "                for i in range(0,int(len(sequence))):\n",
    "                    if sequence[i:i+2] == 'tc' or sequence[i:i+2] == 'ga':\n",
    "                        coordinates[0].append(sequence[i:i+2])\n",
    "                        coordinates[1].append(i+1)\n",
    "                        targetCount += 1                \n",
    "            # Specific site\n",
    "            elif BEfor == 'b':\n",
    "                # Define the target\n",
    "                coordinate = 0\n",
    "                while coordinate == 0:\n",
    "                    coordinate = input('\\nTarget coordinate: ')\n",
    "                    if coordinate.lower() == 'exit': sys.exit(0)\n",
    "                    try:\n",
    "                        coordinate = int(coordinate)\n",
    "                        if coordinate <= 0:\n",
    "                            coordinate = 0\n",
    "                            print('Invalid input! The target coordinate must be a positive integer.')\n",
    "                        elif coordinate > len(sequence):\n",
    "                            coordinate = 0\n",
    "                            print('Invalid input! The target coordinate cannot be outside of the sequence of interest.')\n",
    "                        else:\n",
    "                            coordinates[0].append(sequence[coordinate-1:coordinate-1+2].upper())\n",
    "                            coordinates[1].append(coordinate)\n",
    "                    except ValueError:\n",
    "                        coordinate = 0\n",
    "                        print('Invalid input! The target coordinate must be a positive integer.')\n",
    "                # Check for a target in that specific site\n",
    "                x = sequence[coordinate-1:coordinate+1]\n",
    "                if x == 'tc' or x == 'ga': targetCount += 1\n",
    "            # PTC motifs\n",
    "            elif BEfor == 'c':\n",
    "                triplets = []\n",
    "                for i in range(0,int(len(sequence)/3)):\n",
    "                    triplets.append(sequence[3*i:3*i+3])\n",
    "                    # UAA\n",
    "                    if triplets[i] == 'tga': # TGA -> TAA -> UAA\n",
    "                        coordinates[0].append('TGA')\n",
    "                        coordinates[1].append(3*i+1)\n",
    "                        targetCount += 1\n",
    "                    elif triplets[i] == 'caa': # T|CAA -> T|TAA -> U|UAA\n",
    "                        if i != 0:\n",
    "                            if triplets[i-1][2] == 't':\n",
    "                                coordinates[0].append('TCAA')\n",
    "                                coordinates[1].append(3*i)\n",
    "                                targetCount += 1\n",
    "                    # UAG\n",
    "                    elif triplets[i] == 'cag': # T|CAG -> T|TAG -> U|UAG\n",
    "                        if i != 0:\n",
    "                            if triplets[i-1][2] == 't':\n",
    "                                coordinates[0].append('TCAG')\n",
    "                                coordinates[1].append(3*i)\n",
    "                                targetCount += 1   \n",
    "            proceed = targetCount != 0                    \n",
    "        \n",
    "        # HC-to-HT DdCBE design\n",
    "        elif design == 'c':\n",
    "            coordinates, targetCount = [[],[]], 0\n",
    "            # HC motifs\n",
    "            if BEfor == 'a':\n",
    "                # Find all target sites\n",
    "                for i in range(0,int(len(sequence))):\n",
    "                    # 5'-TC-3' or 5'-GA-3' motifs\n",
    "                    if sequence[i:i+2] == 'tc' or sequence[i:i+2] == 'ga':\n",
    "                        coordinates[0].append(sequence[i:i+2])\n",
    "                        coordinates[1].append(i+1)\n",
    "                        targetCount += 1\n",
    "                    # 5'-CC-3' or 5'-GG-3' motifs\n",
    "                    elif sequence[i:i+2] == 'cc' or sequence[i:i+2] == 'gg':\n",
    "                        coordinates[0].append(sequence[i:i+2])\n",
    "                        coordinates[1].append(i+1)\n",
    "                        targetCount += 1\n",
    "                    # 5'-AC-3' or 5'-GT-3' motifs\n",
    "                    elif sequence[i:i+2] == 'ac' or sequence[i:i+2] == 'gt':\n",
    "                        coordinates[0].append(sequence[i:i+2])\n",
    "                        coordinates[1].append(i+1)\n",
    "                        targetCount += 1\n",
    "            # Specific site\n",
    "            elif BEfor == 'b':\n",
    "                # Define the target\n",
    "                coordinate = 0\n",
    "                while coordinate == 0:\n",
    "                    coordinate = input('\\nTarget coordinate: ')\n",
    "                    if coordinate.lower() == 'exit': sys.exit(0)\n",
    "                    try:\n",
    "                        coordinate = int(coordinate)\n",
    "                        if coordinate <= 0:\n",
    "                            coordinate = 0\n",
    "                            print('Invalid input! The target coordinate must be a positive integer.')\n",
    "                        elif coordinate > len(sequence):\n",
    "                            coordinate = 0\n",
    "                            print('Invalid input! The target coordinate cannot be outside of the sequence of interest.')\n",
    "                        else:\n",
    "                            coordinates[0].append(sequence[coordinate-1:coordinate-1+2].upper())\n",
    "                            coordinates[1].append(coordinate)\n",
    "                    except ValueError:\n",
    "                        coordinate = 0\n",
    "                        print('Invalid input! The target coordinate must be a positive integer.')  \n",
    "                # Check for a target in that specific site\n",
    "                x = sequence[coordinate-1:coordinate+1]\n",
    "                if x == 'tc' or x == 'cc' or x == 'ac' or x == 'ga' or x == 'gg' or x == 'gt': targetCount += 1\n",
    "            # PTC motifs\n",
    "            elif BEfor == 'c':\n",
    "                triplets = []\n",
    "                for i in range(0,int(len(sequence)/3)):\n",
    "                    triplets.append(sequence[3*i:3*i+3])\n",
    "                    # UAA\n",
    "                    if triplets[i] == 'tga': # TGA -> TAA -> UAA\n",
    "                        coordinates[0].append('TGA')\n",
    "                        coordinates[1].append(3*i+1)\n",
    "                        targetCount += 1\n",
    "                    elif triplets[i] == 'caa': # H|CAA -> H|TAA -> H|UAA\n",
    "                        if i != 0:\n",
    "                            if triplets[i-1][2] == 't':\n",
    "                                coordinates[0].append('TCAA')\n",
    "                                coordinates[1].append(3*i)\n",
    "                                targetCount += 1\n",
    "                            elif triplets[i-1][2] == 'c':\n",
    "                                coordinates[0].append('CCAA')\n",
    "                                coordinates[1].append(3*i)\n",
    "                                targetCount += 1\n",
    "                            elif triplets[i-1][2] == 'a':\n",
    "                                coordinates[0].append('ACAA')\n",
    "                                coordinates[1].append(3*i)\n",
    "                                targetCount += 1\n",
    "                    # UAG\n",
    "                    elif triplets[i] == 'tgg': # TGG -> TAG -> UAG\n",
    "                        coordinates[0].append('TGG')\n",
    "                        coordinates[1].append(3*i+1)\n",
    "                        targetCount += 1\n",
    "                    elif triplets[i] == 'cag': # H|CAG -> H|TAG -> H|UAG\n",
    "                        if i != 0:\n",
    "                            if triplets[i-1][2] == 't':\n",
    "                                coordinates[0].append('TCAG')\n",
    "                                coordinates[1].append(3*i)\n",
    "                                targetCount += 1 \n",
    "                            elif triplets[i-1][2] == 'c':\n",
    "                                coordinates[0].append('CCAG')\n",
    "                                coordinates[1].append(3*i)\n",
    "                                targetCount += 1\n",
    "                            elif triplets[i-1][2] == 'a':\n",
    "                                coordinates[0].append('ACAG')\n",
    "                                coordinates[1].append(3*i)\n",
    "                                targetCount += 1\n",
    "                    # AGA\n",
    "                    elif triplets[i] == 'gga': # GGA -> AGA -> AGA\n",
    "                        coordinates[0].append('GGA')\n",
    "                        coordinates[1].append(3*i+1)\n",
    "                        targetCount += 1\n",
    "                    # AGG\n",
    "                    elif triplets[i] == 'ggg': # GGG -> AGG -> AGG\n",
    "                        coordinates[0].append('GGG')\n",
    "                        coordinates[1].append(3*i+1)\n",
    "                        targetCount += 1\n",
    "            proceed = targetCount != 0  \n",
    "        \n",
    "        # If there are motifs\n",
    "        if proceed:\n",
    "            # Identify all possible design permutations\n",
    "            design_list, RE_list = [[],[],[],[],[],[],[],[]], [[],[]]\n",
    "            for i in range(0,len(coordinates[0])): # Include all targets\n",
    "                designCounter = 0 # To count the number of designs\n",
    "                # Additional conditions to avoid 'index out of range' errors\n",
    "                condition5end = coordinates[1][i] >= leftArmMax + spacerMax\n",
    "                condition3end = len(sequence) - coordinates[1][i] >= spacerMax + rightArmMax\n",
    "                if condition5end and condition3end:  \n",
    "                    for j in range (spacerMin,spacerMax+1):\n",
    "                        for k in range(leftArmMin,leftArmMax+1):\n",
    "                            for l in range(rightArmMin,rightArmMax+1):\n",
    "                                for m in range(0,j-len(coordinates[0][i])+1): # Slide target through spacer\n",
    "                                    # Left arm\n",
    "                                    leftArm = sequence[coordinates[1][i]-2-m-k:coordinates[1][i]-1-m]\n",
    "                                    # Spacer (capitalize the targetable motif)\n",
    "                                    spacerX = sequence[coordinates[1][i]-1-m:coordinates[1][i]-1+j-m]\n",
    "                                    spacer = spacerX[0:m] + spacerX[m:m+len(coordinates[0][i])].upper() + spacerX[m+len(coordinates[0][i]):len(spacerX)]\n",
    "                                    # Right arm (matches the actual TALE binding sequence)\n",
    "                                    rightArm = sequence[coordinates[1][i]-1+j-m:coordinates[1][i]+j-m+l]\n",
    "                                    rightArm = reverse_complement(rightArm)\n",
    "                                    # Check the 5'-T constraint\n",
    "                                    if leftArm5 and rightArm5: constraint = leftArm[0] == 't' and rightArm[0] == 't'\n",
    "                                    elif not leftArm5 and rightArm5: constraint = rightArm[0] == 't'\n",
    "                                    elif leftArm5 and not rightArm5: constraint = leftArm[0] == 't'\n",
    "                                    elif not leftArm5 and not rightArm5: constraint = True\n",
    "                                    if constraint:\n",
    "                                        # The motif must be within the 'editing window'\n",
    "                                        if m+1 >= targetWindow and m+2 <= len(spacer) - targetWindow: \n",
    "                                            designCounter += 1 # Increase the design counter\n",
    "                                            # Append target coordinate, target motif, and design index\n",
    "                                            design_list[1].append(coordinates[1][i])\n",
    "                                            design_list[2].append(coordinates[0][i])\n",
    "                                            design_list[3].append(designCounter)\n",
    "                                            # Append off-target(s)\n",
    "                                            if design == 'a': design_list[4].append(0) # TALENs\n",
    "                                            else: # DdCBEs\n",
    "                                                offTargetsTC = spacer.count('tc') + spacer.count('ga')\n",
    "                                                # TC-to-TT\n",
    "                                                if design == 'b': \n",
    "                                                    design_list[4].append(offTargetsTC) \n",
    "                                                # HC-to-HT\n",
    "                                                elif design == 'c': \n",
    "                                                    offTargetsCC = spacer.count('cc') + spacer.count('gg')\n",
    "                                                    offTargetsAC = spacer.count('ac') + spacer.count('gt')\n",
    "                                                    design_list[4].append(offTargetsTC + offTargetsCC + offTargetsAC)\n",
    "                                            # Append left and right arms\n",
    "                                            design_list[5].append(leftArm[1:len(leftArm)]) \n",
    "                                            design_list[6].append(rightArm[1:len(rightArm)])\n",
    "                                            # Identify potential loss of restriction sites in the spacer\n",
    "                                            alignmentStarts, alignmentEnds, REc, REs = 0, 0, 0, ''\n",
    "                                            for n in range(0,len(fullEnzymes_list)):\n",
    "                                                # Take advantage of palindromy to decrease computation time\n",
    "                                                if fullRecognition_list[n] == fullComplements_list[n]:\n",
    "                                                    # Check if the recognition sequence is in the spacer\n",
    "                                                    if fullRecognition_list[n] in spacer.lower():\n",
    "                                                        # Define the limits of the valid alignment range\n",
    "                                                        alignmentStarts = align(spacer, fullRecognition_list[n])[1] - 1\n",
    "                                                        alignmentEnds = len(align(spacer, fullRecognition_list[n])[0])\n",
    "                                                        # Check if the recognition sequence and the target overlap\n",
    "                                                        if m in range(alignmentStarts, alignmentEnds):\n",
    "                                                            REc, REs = REc + 1, REs + fullEnzymes_list[n] + ', '\n",
    "                                                # If the restriction site isn't palindromic\n",
    "                                                elif fullRecognition_list[n] != fullComplements_list[n]:\n",
    "                                                    # Check that the recognition site is in the spacer\n",
    "                                                    if fullRecognition_list[n] in spacer.lower():\n",
    "                                                        # Define the limits of the valid alignment range \n",
    "                                                        alignmentStarts = align(spacer, fullRecognition_list[n])[1] - 1\n",
    "                                                        alignmentEnds = len(align(spacer, fullRecognition_list[n])[0])\n",
    "                                                        # Check if the recognition sequence and the target overlap\n",
    "                                                        if m in range(alignmentStarts, alignmentEnds):\n",
    "                                                            REc, REs = REc + 1, REs + fullEnzymes_list[n] + ', '\n",
    "                                                    # Check if the reverse complement is in the spacer\n",
    "                                                    elif fullComplements_list[n] in spacer.lower():\n",
    "                                                        # Define the limits of the valid alignment range\n",
    "                                                        alignmentStarts = align(spacer, fullComplements_list[n])[1] - 1\n",
    "                                                        alignmentEnds = len(align(spacer, fullComplements_list[n])[0])\n",
    "                                                        # Check if the recognition sequence and the target overlap\n",
    "                                                        if m in range(alignmentStarts, alignmentEnds):\n",
    "                                                            REc, REs = REc + 1, REs + fullEnzymes_list[n] + ', '\n",
    "                                            # Finishing touches\n",
    "                                            if REc != 0: REs = REs[:-1]; REs = REs[:-1]\n",
    "                                            elif REc == 0: REs = 'None'\n",
    "                                            RE_list[0].append(REs) # Append results\n",
    "                                            # Ambiguity (only deterministic in base editing)\n",
    "                                            if design != 'a':\n",
    "                                                # Identify restriction sites (potential gain)                                   \n",
    "                                                alignmentStarts, alignmentEnds, REc, REs = 0, 0, 0, ''\n",
    "                                                # Include on-target edits\n",
    "                                                spacerX = spacer\n",
    "                                                if 'TC' in spacerX: spacerX = spacerX.replace('C','T')\n",
    "                                                elif 'GA' in spacerX: spacerX = spacerX.replace('G','A')\n",
    "                                                if design == 'c': # Add CC-to-CT and AC-to-AT edits\n",
    "                                                    if 'CC' in spacerX: spacerX = spacerX[0:spacerX.index('C') + 1] + 'T' + spacerX[len(spacerX) - 1]\n",
    "                                                    elif 'GG' in spacerX: spacerX = spacerX[0:spacerX.index('G')] + 'C' + spacerX[spacerX.index('G')+1:len(spacerX)]\n",
    "                                                    elif 'AC' in spacerX: spacerX = spacerX.replace('C','T')\n",
    "                                                    elif 'GT' in spacerX: spacerX = spacerX.replace('G','A')\n",
    "                                                # Iterate over the enzymes and their recognition sequences\n",
    "                                                for n in range(0,len(fullEnzymes_list)):\n",
    "                                                    # Take advantage of palindromy to decrease computation time\n",
    "                                                    if fullRecognition_list[n] == fullComplements_list[n]:\n",
    "                                                        # Check if the recognition sequence is in the edited spacer                                        \n",
    "                                                        if fullRecognition_list[n] in spacerX.lower():\n",
    "                                                            # Define the limits of the valid alignment range\n",
    "                                                            alignmentStarts = align(spacerX, fullRecognition_list[n])[1] - 1\n",
    "                                                            alignmentEnds = len(align(spacerX, fullRecognition_list[n])[0])\n",
    "                                                            # Check if the recognition sequence and the target overlap\n",
    "                                                            if m in range(alignmentStarts, alignmentEnds):\n",
    "                                                                REc, REs = REc + 1, REs + fullEnzymes_list[n] + ', '\n",
    "                                                    # If the restriction site isn't palindromic\n",
    "                                                    elif fullRecognition_list[n] != fullComplements_list[n]:\n",
    "                                                        # Check that the recognition site is in the edited spacer\n",
    "                                                        if fullRecognition_list[n] in spacerX.lower():\n",
    "                                                            # Define the limits of the valid alignment range \n",
    "                                                            alignmentStarts = align(spacerX, fullRecognition_list[n])[1] - 1\n",
    "                                                            alignmentEnds = len(align(spacerX, fullRecognition_list[n])[0])\n",
    "                                                            # Check if the recognition sequence and the target overlap\n",
    "                                                            if m in range(alignmentStarts, alignmentEnds):\n",
    "                                                                REc, REs = REc + 1, REs + fullEnzymes_list[n] + ', '\n",
    "                                                        # Check if the reverse complement is in the edited spacer\n",
    "                                                        if fullComplements_list[n] in spacerX.lower():\n",
    "                                                            # Define the limits of the valid alignment range\n",
    "                                                            alignmentStarts = align(spacerX, fullComplements_list[n])[1] - 1\n",
    "                                                            alignmentEnds = len(align(spacerX, fullComplements_list[n])[0])\n",
    "                                                            # Check if the recognition sequence and the target overlap\n",
    "                                                            if m in range(alignmentStarts, alignmentEnds):\n",
    "                                                                REc, REs = REc + 1, REs + fullEnzymes_list[n] + ', '\n",
    "                                                # Finishing touches\n",
    "                                                if REc != 0: REs = REs[:-1]; REs = REs[:-1]\n",
    "                                                elif REc == 0: REs = 'None'\n",
    "                                                RE_list[1].append(REs) # Append results\n",
    "                                            # Append spacer (with highlights)\n",
    "                                            for n in {'A','C','G','T'}: spacer = spacer.replace(n, Back.BLUE + n + Style.RESET_ALL)\n",
    "                                            if design != 'a': # All DdCBEs\n",
    "                                                spacer = spacer.replace('tc', Back.RED + 'tc' + Style.RESET_ALL)\n",
    "                                                spacer = spacer.replace('ga', Back.RED + 'ga' + Style.RESET_ALL)\n",
    "                                                if design == 'c': # HC-to-TT DdCBEs\n",
    "                                                    spacer = spacer.replace('cc', Back.RED + 'cc' + Style.RESET_ALL)\n",
    "                                                    spacer = spacer.replace('gg', Back.RED + 'gg' + Style.RESET_ALL)\n",
    "                                                    spacer = spacer.replace('ac', Back.RED + 'ac' + Style.RESET_ALL)\n",
    "                                                    spacer = spacer.replace('gt', Back.RED + 'gt' + Style.RESET_ALL)\n",
    "                                            design_list[7].append(spacer)\n",
    "\n",
    "            # Remove deterministic ambiguity\n",
    "            if design == 'b': \n",
    "                # Remove false positives enzymes\n",
    "                for i in range(0,len(RE_list[0])):\n",
    "                    s_list = []\n",
    "                    # Find the false positives\n",
    "                    if RE_list[0][i] != 'None' and RE_list[1][i] != 'None':\n",
    "                        s0 = set(RE_list[0][i].replace(' ', '').split(','))\n",
    "                        s1 = set(RE_list[1][i].replace(' ', '').split(','))\n",
    "                        s_list = sorted(s0 & s1)\n",
    "                    # Remove them\n",
    "                    for j in range(0, len(s_list)):\n",
    "                        RE_list[0][i] = RE_list[0][i].replace(s_list[j], '')\n",
    "                        RE_list[1][i] = RE_list[1][i].replace(s_list[j], '')   \n",
    "                    # Finishing touches\n",
    "                    if s_list: \n",
    "                        for j in range(0,2):\n",
    "                            # Only commas and spaces\n",
    "                            p, q = RE_list[j][i] == '', RE_list[j][i] == ', '\n",
    "                            r = (RE_list[j][i]+RE_list[j][i]).find(RE_list[j][i],1,-1) != -1\n",
    "                            if p or q or r: RE_list[j][i] = 'None'\n",
    "                            # Commas, spaces, and letters\n",
    "                            if RE_list[j][i] != ', ':\n",
    "                                # Clean up the beginning if it starts with ','\n",
    "                                if RE_list[j][i][0] == ',':\n",
    "                                    while RE_list[j][i][0:2] == ', ':\n",
    "                                        RE_list[j][i] = RE_list[j][i][2:len(RE_list[j][i])] # HERE\n",
    "                                # Clean up the middle if it contains ', , '\n",
    "                                if ', , ' in RE_list[j][i]:\n",
    "                                    while ', , ' in RE_list[j][i]: RE_list[j][i] = RE_list[j][i].replace(', , ', ', ')                                    \n",
    "                                # Clean up the ending if it ends with ' '\n",
    "                                if RE_list[j][i][len(RE_list[j][i])-1] == ' ':\n",
    "                                    while RE_list[j][i][len(RE_list[j][i])-2:len(RE_list[j][i])] == ', ':\n",
    "                                        RE_list[j][i] = RE_list[j][i][0:len(RE_list[j][i])-2]\n",
    "\n",
    "            # Correctly append target numbers\n",
    "            targetCounter = 1\n",
    "            for i in range(0,len(design_list[1])):\n",
    "                if i > 0:\n",
    "                    if design_list[1][i] != design_list[1][i-1]:\n",
    "                        targetCounter += 1\n",
    "                design_list[0].append(targetCounter)\n",
    "\n",
    "            # If there are no viable design permutations\n",
    "            if not design_list[0]:\n",
    "                print('\\nThere are no viable design permutations!')\n",
    "                # Ask to try another sequence\n",
    "                newSequenceX = 0\n",
    "                while newSequenceX == 0:\n",
    "                    newSequenceX = input('\\nNew sequence? ')\n",
    "                    if newSequenceX.lower() == 'exit': sys.exit(0)\n",
    "                    newSequenceX = newSequenceX.lower()\n",
    "                    if newSequenceX not in {'yes','y','no','n'}:\n",
    "                        newSequenceX = 0\n",
    "                        print(\"Invalid input! Type 'yes' or 'no'\")\n",
    "                    elif newSequenceX in {'no','n'}: newSequence = False\n",
    "\n",
    "            # Highlight targetable motifs\n",
    "            elif design_list[0]:\n",
    "                targetLength = 0\n",
    "                for i in range(0,len(design_list[1])):\n",
    "                    targetLength = len(design_list[2][i])\n",
    "                    sequence = sequence[:design_list[1][i]-1]+sequence[design_list[1][i]-1:design_list[1][i]-1+targetLength].upper()+sequence[design_list[1][i]-1+targetLength:]           \n",
    "                # Add blue highlights to the entire sequence\n",
    "                for i in {'A','C','G','T'}: sequence = sequence.replace(i, Back.BLUE + i + Style.RESET_ALL)\n",
    "                print('\\nSequence (with target/s): ' + sequence + '\\n')\n",
    "\n",
    "                # DISPLAY RESULTS\n",
    "                \n",
    "                # Additional lists to avoid saturating the displayed df\n",
    "                loss_list, gain_list = [], []\n",
    "                for i in range(0,len(RE_list[0])):\n",
    "                    if RE_list[0][i] == 'None': loss_list.append('No')\n",
    "                    else: loss_list.append('Yes')\n",
    "                    if design != 'a': # DdCBEs\n",
    "                        if RE_list[1][i] == 'None': gain_list.append('No')\n",
    "                        else: gain_list.append('Yes')\n",
    "                \n",
    "                # Create a dataframe containing the results\n",
    "                if design == 'a': # TALENs\n",
    "                    if TALENfor == 'a': # All targets\n",
    "                        results_df = pd.DataFrame({'TGT':design_list[0],\n",
    "                                                   'COORD':design_list[1],\n",
    "                                                   'DSG':design_list[3],\n",
    "                                                   'LOSS':loss_list,\n",
    "                                                   'LEFT SEQUENCE':design_list[5],\n",
    "                                                   'RIGHT SEQUENCE':design_list[6],\n",
    "                                                   'SPACER SEQUENCE':design_list[7]})\n",
    "                    elif TALENfor == 'b': # Specific site\n",
    "                        results_df = pd.DataFrame({'DSG':design_list[3],\n",
    "                                                   'LOSS':loss_list,\n",
    "                                                   'LEFT SEQUENCE':design_list[5],\n",
    "                                                   'RIGHT SEQUENCE':design_list[6],\n",
    "                                                   'SPACER SEQUENCE':design_list[7]})\n",
    "                else: # DdCBEs\n",
    "                    results_df = pd.DataFrame({'TGT':design_list[0],\n",
    "                                               'COORD':design_list[1],\n",
    "                                               'DSG':design_list[3],\n",
    "                                               'LOSS':loss_list,\n",
    "                                               'GAIN':gain_list,\n",
    "                                               'OFF':design_list[4],\n",
    "                                               'LEFT SEQUENCE':design_list[5],\n",
    "                                               'RIGHT SEQUENCE':design_list[6],\n",
    "                                               'SPACER SEQUENCE':design_list[7]})\n",
    "                print(tabulate(results_df, showindex=False, headers=results_df.columns))\n",
    "\n",
    "                # Visualizing the design permutation distribution\n",
    "                if design_list[0][-1] > 1:\n",
    "                    print('\\nThere are ' + str(design_list[0][-1]) + ' potential targets and a total of ' + str(len(design_list[0])) + ' design permutations.')\n",
    "                    print('\\nDesign permutation distribution:')\n",
    "                    fig_size, fig_size[0], fig_size[1] = plt.rcParams[\"figure.figsize\"], 10, 6\n",
    "                    fig, ax = plt.subplots()\n",
    "                    ax.set(xlabel = 'Target', ylabel = 'Designs')\n",
    "                    permutationsGraph_list, subtract = [], 0\n",
    "                    for i in range(0,len(design_list[0])):\n",
    "                        if design_list[0][i] > design_list[0][i-1]:\n",
    "                            permutationsGraph_list.append(i-subtract)\n",
    "                            subtract = i       \n",
    "                    permutationsGraph_list.append(design_list[0].count(design_list[0][-1]))\n",
    "                    permutationsGraph = np.zeros((len(permutationsGraph_list)))\n",
    "                    for i in range(0,len(permutationsGraph_list)): permutationsGraph[i] = int(permutationsGraph_list[i])\n",
    "                    i = np.arange(1, design_list[0][-1] + 1, 1)\n",
    "                    ax.scatter(i, permutationsGraph, c = 'black', s = 4)\n",
    "                    ax.plot(i, permutationsGraph, c = 'gray', linewidth = 1, linestyle = '-') \n",
    "                    ax.set_ylim(0, np.amax(permutationsGraph) + 1)\n",
    "                    plt.show()\n",
    "                else: print('\\nThere is 1 potential target and ' + str(len(design_list[0])) + ' design permutations.\\n')\n",
    "                \n",
    "                # Save results\n",
    "                save, name = 0, 0\n",
    "                while save == 0:\n",
    "                    save = input('Save results as CSV file? ')\n",
    "                    if save.lower() == 'exit': sys.exit(0)\n",
    "                    save = save.lower()\n",
    "                    if save not in {'yes','y','no','n'}:\n",
    "                        save = 0\n",
    "                        print(\"Invalid input! Type 'yes' or 'no'\\n\")\n",
    "                    elif save in {'yes','y'}:\n",
    "                        while name == 0:\n",
    "                            name = input('\\nAlphanumeric filename: ')\n",
    "                            if name.lower() == 'exit': sys.exit(0)\n",
    "                            if name.isalnum():\n",
    "                                # Get rid of colorama markers\n",
    "                                for i in range(0, len(design_list[7])):\n",
    "                                    design_list[7][i] = design_list[7][i].replace('\\x1b[41m','')\n",
    "                                    design_list[7][i] = design_list[7][i].replace('\\x1b[44m','')\n",
    "                                    design_list[7][i] = design_list[7][i].replace('\\x1b[0m','')\n",
    "                                # Create a new dataframe without highlights\n",
    "                                if design == 'a': # TALENs\n",
    "                                    if TALENfor == 'a': # All targets\n",
    "                                        save_df = pd.DataFrame({'TGT':design_list[0],\n",
    "                                                                'COORD':design_list[1],\n",
    "                                                                'DES':design_list[3],\n",
    "                                                                'POTENTIAL LOSS':RE_list[0],\n",
    "                                                                'LEFT SEQUENCE':design_list[5],\n",
    "                                                                'SPACER SEQUENCE':design_list[7],\n",
    "                                                                'RIGHT SEQUENCE':design_list[6]})\n",
    "                                    elif TALENfor == 'b': # Specific site\n",
    "                                        save_df = pd.DataFrame({'DES':design_list[3],\n",
    "                                                                'POTENTIAL LOSS':RE_list[0],\n",
    "                                                                'LEFT SEQUENCE':design_list[5],\n",
    "                                                                'SPACER SEQUENCE':design_list[7],\n",
    "                                                                'RIGHT SEQUENCE':design_list[6]})\n",
    "                                else: # DdCBEs\n",
    "                                    save_df = pd.DataFrame({'TGT':design_list[0],\n",
    "                                                            'COORD':design_list[1],\n",
    "                                                            'DES':design_list[3],\n",
    "                                                            'LOSS':RE_list[0],\n",
    "                                                            'GAIN':RE_list[1],\n",
    "                                                            'OFF':design_list[4],\n",
    "                                                            'LEFT SEQUENCE':design_list[5],\n",
    "                                                            'SPACER SEQUENCE':design_list[7],\n",
    "                                                            'RIGHT SEQUENCE':design_list[6]})\n",
    "                                save_df.index += 1 # Start index at 1\n",
    "                                save_df.to_csv(name + '.csv') # Save dataframe\n",
    "                            else:\n",
    "                                name = 0\n",
    "                                print('Invalid input! File name must be alphanumeric.')\n",
    "\n",
    "                # After everything worked, ask for new sequence\n",
    "                newSequenceX = 0\n",
    "                while newSequenceX == 0:\n",
    "                    newSequenceX = input('\\nNew sequence? ')\n",
    "                    if newSequenceX.lower() == 'exit': sys.exit(0)\n",
    "                    newSequenceX = newSequenceX.lower()\n",
    "                    if newSequenceX not in {'yes','y','no','n'}:\n",
    "                        newSequenceX = 0\n",
    "                        print(\"Invalid input! Type 'yes' or 'no'\")\n",
    "                    elif newSequenceX in {'no','n'}: newSequence = False\n",
    "\n",
    "        elif not proceed: print('\\nThere are no target sites!') # If there are no targetable motifs\n",
    "    \n",
    "    # New analysis?\n",
    "    newAnalysis = 0\n",
    "    while newAnalysis == 0:\n",
    "        newAnalysis = input('\\nNew analysis? ')\n",
    "        if newAnalysis.lower() == 'exit': sys.exit(0)\n",
    "        if newAnalysis.lower() not in {'yes','y','no','n'}:\n",
    "            newAnalysis = 0\n",
    "            print(\"Invalid input! Type 'yes' or 'no'\")\n",
    "        elif newAnalysis.lower() in {'no','n'}: input('\\nBye :-)')\n",
    "        elif newAnalysis.lower() in {'yes','y'}: newAnalysis = 'yes'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Number of targets: 2\n",
      "\n",
      "Target sequence 1: ggaggccggagcagga\n",
      "\n",
      "Target sequence 2: gctaagggagggtag\n",
      "\n",
      "Target sequence    Corresponding RVDs                                 X1    X2    X3    X4  B2    B3    LR\n",
      "-----------------  -----------------------------------------------  ----  ----  ----  ----  ----  ----  ----\n",
      "ggaggccggagcagga   NN NN NI NN NN HD HD NN NN NI NN HD NI NN NN NI    41    42    27    10        11    NI\n",
      "gctaagggagggtag    NN HD NG NI NI NN NN NN NI NN NN NN NG NI NN       40     3    41    43  13          NN\n",
      "\n",
      "Save results as CSV file? no\n",
      "\n",
      "Bye :-)\n"
     ]
    }
   ],
   "source": [
    "# TALE RVD SEQUENCES\n",
    "\n",
    "# Libraries\n",
    "RVDs_list, FusXB, FusB2 = ['NI','HD','NN','NG'], [], [] # A, C, G, T\n",
    "for i in range(0,4):\n",
    "    for j in range(0,4):\n",
    "        FusB2.append(RVDs_list[i] + ' ' + RVDs_list[j]) # FusB2\n",
    "        for k in range(0,4):\n",
    "            FusXB.append(RVDs_list[i] + ' ' + RVDs_list[j] + ' ' + RVDs_list[k]) # FusX1-4/B3\n",
    "\n",
    "# Number of targets\n",
    "n = 0\n",
    "while n == 0:\n",
    "    n = input('\\nNumber of targets: ')\n",
    "    if n.lower() == 'exit': sys.exit(0)\n",
    "    try:\n",
    "        n = int(n)\n",
    "        if n < 0:\n",
    "            n = 0\n",
    "            print('Invalid input! Must be a positive integer.')\n",
    "    except:\n",
    "        n = 0\n",
    "        print('Invalid input! Must be a positive integer.')\n",
    "        \n",
    "# Target sequences and corresponding RVDs\n",
    "pFusX1, pFusX2, pFusX3, pFusX4, pFusB2, pFusB3, pLR = [],[],[],[],[],[],[]\n",
    "target_list, motifs_list = [],[] # Intermediate lists\n",
    "allFusX = True # Auxiliar boolean variable\n",
    "for i in range(0, n):    \n",
    "    # Define target sequence\n",
    "    target = 0\n",
    "    while target == 0:\n",
    "        target = input('\\nTarget sequence ' + str(i+1) + ': ')\n",
    "        if target.lower() == 'exit': sys.exit(0)\n",
    "        if target == '':\n",
    "            target = 0\n",
    "            print('Invalid input! Must be a DNA sequence.')\n",
    "        else:\n",
    "            targetX = target\n",
    "            target = target.lower()\n",
    "            j = 0\n",
    "            while j in range(0, len(targetX)):\n",
    "                if target[j] not in {'a','c','g','t'}:\n",
    "                    j = len(target)\n",
    "                    target = 0\n",
    "                    print('Invalid input! Must be a DNA sequence.')\n",
    "                else: j += 1\n",
    "    target_list.append(target)\n",
    "    \n",
    "    # Auxiliar boolean statement to avoid displaying errors\n",
    "    if not 15 <= len(target) <= 16:\n",
    "        print('\\nWarning! Target length is not FusX-compatible.')\n",
    "        allFusX = False\n",
    "                    \n",
    "    # Determine RVDs\n",
    "    specificMotif = ''\n",
    "    for i in range(0, len(target)):\n",
    "        if i == len(target) - 1:\n",
    "            if target[i] == 'a': specificMotif = specificMotif + RVDs_list[0]\n",
    "            elif target[i] == 'c': specificMotif = specificMotif + RVDs_list[1]\n",
    "            elif target[i] == 'g': specificMotif = specificMotif + RVDs_list[2]\n",
    "            elif target[i] == 't': specificMotif = specificMotif + RVDs_list[3]         \n",
    "        else:\n",
    "            if target[i] == 'a': specificMotif = specificMotif + RVDs_list[0] + ' '\n",
    "            elif target[i] == 'c': specificMotif = specificMotif + RVDs_list[1] + ' '\n",
    "            elif target[i] == 'g': specificMotif = specificMotif + RVDs_list[2] + ' '\n",
    "            elif target[i] == 't': specificMotif = specificMotif + RVDs_list[3] + ' ' \n",
    "    motifs_list.append(specificMotif)\n",
    "    \n",
    "    # Determine plasmids\n",
    "    if 15 <= len(target) <= 16:\n",
    "        for i in range(0,len(FusXB)):\n",
    "            if FusXB[i] == specificMotif[0:8]:\n",
    "                pFusX1.append(i+1)\n",
    "            if FusXB[i] == specificMotif[9:17]:\n",
    "                pFusX2.append(i+1)\n",
    "            if FusXB[i] == specificMotif[18:26]:\n",
    "                pFusX3.append(i+1)\n",
    "            if FusXB[i] == specificMotif[27:35]:\n",
    "                pFusX4.append(i+1)\n",
    "        if len(target) == 15:\n",
    "            for i in range(0,len(FusB2)):\n",
    "                if FusB2[i] == specificMotif[36:41]:\n",
    "                    pFusB2.append(i+1)\n",
    "                    pFusB3.append(' ')\n",
    "            pLR.append(specificMotif[42:])\n",
    "        else:\n",
    "            for i in range(0,len(FusXB)):\n",
    "                if FusXB[i] == specificMotif[36:44]:\n",
    "                    pFusB2.append(' ')\n",
    "                    pFusB3.append(i+1)\n",
    "            pLR.append(specificMotif[45:])  \n",
    "\n",
    "# Display results\n",
    "if allFusX == True: # Include plasmids only if all target sequences are FusX-compatible\n",
    "    df = pd.DataFrame({'Target sequence': target_list,\n",
    "                       'Corresponding RVDs': motifs_list,\n",
    "                       'X1':pFusX1,\n",
    "                       'X2':pFusX2,\n",
    "                       'X3':pFusX3,\n",
    "                       'X4':pFusX4,\n",
    "                       'B2':pFusB2,\n",
    "                       'B3':pFusB3,\n",
    "                       'LR':pLR})\n",
    "else: df = pd.DataFrame({'Target sequence': target_list, 'Corresponding RVDs': motifs_list})\n",
    "print('\\n' + tabulate(df, showindex=False, headers=df.columns))\n",
    "\n",
    "# Save results\n",
    "save, name = 0, 0\n",
    "while save == 0:\n",
    "    save = input('\\nSave results as CSV file? ')\n",
    "    if save.lower() == 'exit': sys.exit(0)\n",
    "    save = save.lower()\n",
    "    if save not in {'yes','y','no','n'}:\n",
    "        save = 0\n",
    "        print(\"Invalid input! Type 'yes' or 'no'\\n\")\n",
    "    elif save in {'yes','y'}:\n",
    "        while name == 0:\n",
    "            name = input('\\nAlphanumeric filename: ')\n",
    "            if name.lower() == 'exit': sys.exit(0)\n",
    "            if name.isalnum():\n",
    "                df.index += 1 # Start index at 1\n",
    "                df.to_csv(name + '.csv') # Save dataframe\n",
    "            else:\n",
    "                name = 0\n",
    "                print('Invalid input! File name must be alphanumeric.')\n",
    "                \n",
    "# Exit\n",
    "boolX = False\n",
    "while boolX == False:\n",
    "    boolX = True\n",
    "    input('\\nBye :-)')"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}