Notebooks/pdbSoftwareTools.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MAIN DISPALY MENU   \n",
    "\n",
    "def menu():\n",
    "    \"\"\"\n",
    "    Function: Displays the menu with different options for the user\n",
    "    Arguments: None\n",
    "    Returns: Menu\n",
    "    \n",
    "    \"\"\"\n",
    "    blue = lambda text: '\\033[0;34m' + text + '\\033[0m' # Colors the printed output blue\n",
    "    red = lambda text: '\\033[0;31m' + text + '\\033[0m'\n",
    "    software = \"PDB FILE ANALYZER\"\n",
    "    choices = \"Select an option from below:\"\n",
    "    c1 = \"1) Open a PDB file                     (O)\"\n",
    "    c2 = \"2) Information                         (I)\"\n",
    "    c3 = \"3) Show histrogram of amino acids      (H)\"\n",
    "    c4 = \"4) Display Secondary Structure         (S)\"\n",
    "    c5 = \"5) Export PDB File                     (X)\"\n",
    "    c6 = \"6) Exit                                (Q)\"\n",
    "    global file\n",
    "    status = \"Current PDB: \"+ file\n",
    "    len(software)\n",
    "\n",
    "    stars=\"*\"\n",
    "    space=\" \"\n",
    "    print(blue(stars*80))\n",
    "    #The length of the inserted string and its 0 index is subtracted for the desired 80 characters per line to be met.\n",
    "    #Subtract index 0s in each object added, this concept is applied to each line.\n",
    "    print(blue(stars * 1),blue(\"%0s\"%\"\"),blue(\"%s\"%software),space*(75-(len(software)))+blue(stars))\n",
    "    print(blue(stars*80))\n",
    "    print(blue(stars * 1),\"%0s\"%\"\",blue(\"%s\" %choices),space*(75-(len(choices)))+blue(stars) ) \n",
    "    print(blue(stars*1), blue(space*76), blue(stars*1))\n",
    "    print(blue(stars * 1),\"%5s\"%\"\",blue(\"%s\" %c1),space*(70-(len(c1)))+blue(stars))\n",
    "    print(blue(stars * 1),\"%5s\"%\"\",blue(\"%s\"%c2),space*(70-(len(c2)))+blue(stars))\n",
    "    print(blue(stars * 1),\"%5s\"%\"\",blue(\"%s\" %c3),space*(70-(len(c3)))+blue(stars))\n",
    "    print(blue(stars * 1),\"%5s\"%\"\",blue(\"%s\" %c4),space*(70-(len(c4)))+blue(stars))\n",
    "    print(blue(stars * 1),\"%5s\"%\"\",blue(\"%s\" %c5),space*(70-(len(c5)))+blue(stars))\n",
    "    print(blue(stars * 1),\"%5s\"%\"\",blue(\"%s\" %c6),space*(70-(len(c6)))+blue(stars))\n",
    "    print(blue(stars * 1),\"%0s\"%\"\",space*(74-(len(status))),blue(\"%s\" %status),blue(stars*1))\n",
    "    print(blue(stars*80))\n",
    "    global choice\n",
    "    choice = input(\":\")    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PDB FILE FORMART TEST\n",
    "def fungua(filename):\n",
    "    \"\"\"\n",
    "    Function: Opens and tests a valid file path by loading it to the memory \n",
    "              Test if the file is a pdb file\n",
    "    Argument: Name or valid path of the file\n",
    "    \n",
    "    \"\"\"\n",
    "    red = lambda text: '\\033[0;31m' + text + '\\033[0m'\n",
    "    \n",
    "    from pathlib import Path\n",
    "    filename = Path(filename)    \n",
    "    try:\n",
    "        with open(filename, 'r') as f:\n",
    "            global file \n",
    "            file = filename.name\n",
    "            checkList= ['HEADER','OBSLTE','TITLE','SPLT','CAVEAT','COMPND','SOURCE','KEYWDS','EXPDTA','NUMMDL','MDLTYP',\\\n",
    "        'AUTHOR','REVDAT','SPRSDE','JRNL','REMARKS','DBREF','DBREF1','DBREF2','SEQADV','SEQRES','MODRES',\\\n",
    "        'HET','FORMUL','HETNAM','HETSYN','HELIX','SHEET','SSBOND','LINK','CISPEP','SITE','CRYST1','MTRIXn',\\\n",
    "        'ORIGXn','SCALEn','MODEL','ATOM','ANISOU','TER','HETATM','ENDMDL','CONECT','MASTER','END']\n",
    "            checkList = ','.join(checkList)\n",
    "            for line in f:\n",
    "                if len(line) == 81:\n",
    "                    pass\n",
    "                    starts = str(line[:6])\n",
    "                    status = True\n",
    "                    for i in starts:\n",
    "                        if i in checkList:\n",
    "                            pass\n",
    "                        else:\n",
    "                            status = False\n",
    "                    return status\n",
    "    except:\n",
    "            print(red(\"Invalid file loaded.\"))\n",
    "            \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "## CHOICES OPTIONS\n",
    "def choiceO():\n",
    "    \"\"\"Function: loads the file to the software\"\"\"\n",
    "    red = lambda text: '\\033[0;31m' + text + '\\033[0m'\n",
    "    global load_file        # Retains the loaded file the memory of the software allowing other functions to open the file using this variable\n",
    "    load_file = str(input('Enter a Valid PATH for a PDB File:'))\n",
    "    if fungua(load_file) == True:\n",
    "        try:\n",
    "            print(red(\"The File %s has been sucessfully loaded\" %load_file))\n",
    "        except:\n",
    "            print(red(\"Ivalid file loaded\"))\n",
    "            global file        #Displays the name of the file on the menu as long as it is loaded\n",
    "            file = \"None\"\n",
    "    else:\n",
    "        print(red(\"The file loaded does not follow the pdb format.\\nPlease Enter a valid  pdb file\"))\n",
    "        menu()\n",
    "        choiceO()\n",
    "    menu()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CHOICES INFORMATION\n",
    "def choiceI():\n",
    "    \"\"\"Function prints a summary of the general description of the pdb file\"\"\"\n",
    "    titlePdb() # prints the file name and the title of th pdb file\n",
    "    printChains(load_file)\n",
    "    chainInfo(load_file)\n",
    "    menu()\n",
    "\n",
    "##\n",
    "def titlePdb():\n",
    "    \"\"\"\n",
    "    Function: Extracts the title from the pdb file.\n",
    "    \n",
    "    \"\"\"\n",
    "    from pathlib import Path\n",
    "    red = lambda text: '\\033[0;31m' + text + '\\033[0m'\n",
    "    if fungua(load_file):\n",
    "        myLis = []\n",
    "        myFile = Path(load_file)\n",
    "        with open(load_file, 'r') as f:\n",
    "            global file \n",
    "            file = myFile.name\n",
    "            print(\"PDB File: %s \" %red(file) )\n",
    "            Title = \"\"\n",
    "            for line in f:\n",
    "                if line.startswith('TITLE'):\n",
    "                    Title = line.strip('TITLE')\n",
    "                    Title = Title.strip()\n",
    "                    myLis.append(Title)\n",
    "            myString = str((\"\").join(myLis)) # joining the list and converting it into a string\n",
    "            myString = \"Title: \" + myString.strip()\n",
    "            if len(myString) <= 80:\n",
    "                print(myString[:80])\n",
    "            else:\n",
    "                print(myString[:80]+\"\\n\"+myString[80:])\n",
    "\n",
    "##\n",
    "def printChains(load_file):\n",
    "    \"\"\" \n",
    "    Input: pdb file\n",
    "    Function: Prints all the chains in the pdb file\n",
    "    \"\"\"\n",
    "    with open(load_file, 'r') as f:\n",
    "        chain = list(\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\")\n",
    "        lyst = \"\"\n",
    "        for line in f:\n",
    "            if line.startswith('SEQRES'):\n",
    "                s = line.split()[2:]         # creaeting a list of our three letter code amino acids and displays starting from the chain type\n",
    "                for i in s:\n",
    "                    for letter in chain:\n",
    "                        if i == letter:\n",
    "                            lyst+= letter\n",
    "        lyst = sorted(lyst)             #sort the list\n",
    "        lyst = list(dict.fromkeys(lyst)) # remove duplicates leaving us with the number of chains in the pdb file\n",
    "        lyst = \"\".join(lyst)\n",
    "        global chainString\n",
    "        chainString = str(lyst[:-1])+str(lyst[-1])\n",
    "        allChains = str(lyst[:-1])+' '+'and'+' '+str(lyst[-1])\n",
    "        print('Chains: '+ allChains)\n",
    "        \n",
    "##\n",
    "def chainInfo(load_file):\n",
    "\n",
    "    import textwrap # introduces prints stirng of specified length\n",
    "\n",
    "    aa_dic = {'A':'ALA', 'R':'ARG', 'N':'ASN', 'D':'ASP', 'G':'GLY', 'Q':'GLN', 'E':'GLU', 'H':'HIS','C':'CYS',\\\n",
    "              'I':'ILE', 'L':'LEU', 'K':'LYS', 'M':'MET', 'F':'PHE', 'P':'PRO', 'S':'SER', 'T':'THR', 'W':'TRP', 'Y':'TYR', 'V':'VAL'} # dictionary for amino acids\n",
    "    new_dict = dict([(value, key) for (key, value) in aa_dic.items()]) # swapped the values and keys \n",
    "\n",
    "\n",
    "    def no_aa(seq):\n",
    "        \"\"\"Input: amino acid sequence\n",
    "           Fuinction: number of amino acids in a chain   \n",
    "        \"\"\"\n",
    "        return (len(seq)-(len(seq)//50))\n",
    "\n",
    "    def getHelixNos(chain):\n",
    "        \"\"\"Input: chain name e.g \"A\", \"B\" ...\n",
    "           Function: counts the number of helices in a chain\n",
    "        \"\"\"\n",
    "        with open(load_file, 'r') as f:\n",
    "            h = \"\"\n",
    "            for line in f:\n",
    "                if line.startswith('HELIX'):\n",
    "                    l = line.split()[4:]\n",
    "                    if l[0] == chain:\n",
    "                        h += l[0]\n",
    "            return (len(h))\n",
    "\n",
    "\n",
    "    def getSheetNos(chain):\n",
    "        \"\"\"Input: chain name e.g \"A\", \"B\" ...\n",
    "           Function: counts the number of sheets in a chain\n",
    "        \"\"\"\n",
    "        with open(load_file, 'r') as f:\n",
    "            sh = \"\" \n",
    "            for line in f:\n",
    "                if line.startswith('SHEET'):\n",
    "                    l = line.split()[5:]\n",
    "                    if l[0] == chain:\n",
    "                        sh += l[0]\n",
    "            return (len(sh))\n",
    "\n",
    "\n",
    "    with open(load_file, 'r') as f:\n",
    "        chains = []\n",
    "        for line in f:\n",
    "            if line.startswith('SEQRES'):\n",
    "                l = line.split()[2:]         # creaeting a list of our three letter code amino acids and displays starting from the chain type\n",
    "                chains.append(l[0])\n",
    "                chains = (list(dict.fromkeys(chains)))\n",
    "\n",
    "        for i in chains:\n",
    "            seq = \"\"\n",
    "            with open(load_file, 'r') as f:\n",
    "                for line in f:\n",
    "                    l = line.split()\n",
    "                    if line.startswith('SEQRES')and i == l[2]:\n",
    "                        l = l[4:]\n",
    "                        c = [new_dict[codon]for codon in l]\n",
    "                        seq += \"\".join(c)\n",
    "            space = \" \"\n",
    "            s = (\"\\n\"+space*15).join(textwrap.wrap(seq,50))\n",
    "            print(\" - Chain %s\" % i)\n",
    "            print(\"%4s Number of amino acids: \"%\"\",no_aa(seq))\n",
    "            print(\"%4s Number of helix: %9d\"%(\"\",getHelixNos(i)))\n",
    "            print(\"%4s Number of sheet: %9d\"%(\"\",getSheetNos(i)))\n",
    "            print(\"%4s Sequence: %s\" % (\"\",s))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Choice H  - Amino acids histograms\n",
    "def choiceH():\n",
    "    red = lambda text: '\\033[0;31m' + text + '\\033[0m'\n",
    "    options()\n",
    "    if option.lower() in ('an', 'dn', 'aa', 'da'):\n",
    "        selectionOutput(option,load_file)\n",
    "    else:\n",
    "        print(red(\"Please enter a valid option\"))\n",
    "        choiceH()\n",
    "##\n",
    "def options():\n",
    "    blue = lambda text: '\\033[0;34m' + text + '\\033[0m'\n",
    "    print(blue(\"Choose an option to order by:\"))\n",
    "    print(blue(\"   number of amino acids - ascending  (an)\"))\n",
    "    print(blue(\"   number of amino acids - descending (dn)\"))\n",
    "    print(blue(\"   alphabetically - ascending         (aa)\"))\n",
    "    print(blue(\"   alphabetically - descending        (da)\"))\n",
    "    global option\n",
    "    option = input(\"Order by:\")\n",
    "\n",
    "##\n",
    "def selectionOutput(option,load_file):\n",
    "    \"\"\"\n",
    "        Input: options on the display i.e. an', 'dn', 'aa' and 'da'\n",
    "        Function: prints a summary of the amino acids in a pdb files according to the number of times an amino acid is in the sequence\n",
    "    \"\"\"\n",
    "    with open(load_file, 'r') as f:\n",
    "        seq = []\n",
    "        for line in f:\n",
    "            if line.startswith('SEQRES'):\n",
    "                l = line.split()[4:]       # creaeting a list of our three letter code amino acids and displays starting from the chain type\n",
    "                seq += l\n",
    "    sL = []\n",
    "    dic = dict()\n",
    "    for i in seq:\n",
    "        sL.append(i)\n",
    "    for aa in sL:\n",
    "        dic[aa] = dic.get(aa,0) + 1\n",
    "\n",
    "    if option.lower() == 'aa':\n",
    "        # Alphabetically sorted amino acid histograms aa (ascending)\n",
    "        sort_Aa_dic = (dict(sorted(dic.items(), key = lambda t : t[0])))\n",
    "        sortedDic = dict(sort_Aa_dic)\n",
    "        for k,v in sortedDic.items():\n",
    "            print(k, \"( %2d)\" %v,\": \"+\"*\"*v)\n",
    "\n",
    "    elif option.lower() ==\"da\":\n",
    "        # Alphabetically sorted amino acid histograms da (descending)\n",
    "        sort_Aa_dic = (dict(sorted(dic.items(), key = lambda t : t[0], reverse = True)))\n",
    "        sortedDic = dict(sort_Aa_dic)\n",
    "        for k,v in sortedDic.items():\n",
    "            print(k, \"( %2d)\" %v,\": \"+\"*\"*v)\n",
    "    elif option.lower() ==\"dn\":\n",
    "        # choice dn decending ( by number of amino acids)\n",
    "        sort_no_aa_dic = (sorted(dic.items(), key = lambda t : t[1]))\n",
    "        s = dict(sort_no_aa_dic)\n",
    "\n",
    "        for k,v in s.items():\n",
    "            print(k, \"( %2d)\" %v,\": \"+\"*\"*v)\n",
    "    \n",
    "    elif option.lower() ==\"an\":\n",
    "        # choice an acending ( by number of amino acids)\n",
    "        sort_no_aa_dic = (sorted(dic.items(), key = lambda t : t[1], reverse = True))\n",
    "        s = dict(sort_no_aa_dic)\n",
    "\n",
    "        for k,v in s.items():\n",
    "            print(k, \"( %2d)\" %v,\": \"+\"*\"*v)\n",
    "    else:\n",
    "        print(\"Invalid selection made! Try again\")\n",
    "    menu()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CHOICE S\n",
    "def choiceS(load_file):    \n",
    "    \"\"\"Input: pdb file\n",
    "       Functions: displays the secondary structure of a pdb file\n",
    "    \"\"\"\n",
    "    print(\"Secondary Structure of the PDB id %s\"%load_file)                        \n",
    "    def seq_helix_sheet3D(load_file, seq, chain):\n",
    "\n",
    "        \"\"\"Input: pdb file, sequence of a particular chain from the pdb, the chain name of the sequence eg \"A\",\"B\",\"P\" etc\n",
    "           Function: creats for you a sequence with its sheets, lables and helixes and prints them in tandem\n",
    "        \"\"\"\n",
    "\n",
    "        # HELIX symbols(/) and its lables\n",
    "        seq3D = []\n",
    "        lable3D= []                                 # empty list for the lable line\n",
    "        for i in range(0, len(seq)):\n",
    "            seq3D.append(\"-\")\n",
    "            lable3D.append(\" \")                     # append an empty space for our lables\n",
    "\n",
    "        with open(load_file, 'r') as f:\n",
    "            helixIndexes = []                      # new empty list for appending all indexes for the helix chain that will enable us to replace dashes with helix symbols\n",
    "            lableIndexes = []                      # new empty list for appending index where each helix is located\n",
    "            lables = []                            # empty list for the chain numbers\n",
    "            for line in f:\n",
    "                if line.startswith('HELIX'):\n",
    "                    newl = line.split()            # split our lines into a list with individual items that we can easily access\n",
    "                    if newl[4] == chain:\n",
    "                        frm = int(newl[5])          # Extract the start sequence index from the pdb\n",
    "                        to = int(newl[8])           # Extract the end index for the helix from the pdb file\n",
    "                        lables.append(newl[2])       # appends the lable for all the helixes on alist\n",
    "                        lableIndexes.append(frm)     # append the indexes that will  mark  the point the helix is starting\n",
    "                        for i in range(frm,to+1):      # using the range extracted above prints in to the list all the indexes of the aa in that helix to a list\n",
    "                            helixIndexes.append(i)\n",
    "\n",
    "        for i in range(0,len(lableIndexes)):         # convert the values on the LableIndex list into integers\n",
    "            lableIndexes[i] = int(lableIndexes[i])\n",
    "\n",
    "        for (index, lable) in zip(lableIndexes, lables): # Replacing the lable3D list at the specific indexes with the lables\n",
    "            if len(lable) > 1:                                      # if the lable has more lab one character we want to make the two characters to be read as one\n",
    "                lable3D[index-1:index+len(lable)-1] =lable\n",
    "            else:\n",
    "                lable3D[index-1] = lable\n",
    "        labler = (\"\".join(lable3D))    \n",
    "\n",
    "        replace = ''                                    # creating a string containg the symbols for helixes for each index for the index list created before(helixIndex)\n",
    "        for i in range(0,len(helixIndexes)+1):\n",
    "            replace+=\"/\"\n",
    "\n",
    "        for i in range(0,len(helixIndexes)):            # convertring items in the list in to integers\n",
    "            helixIndexes[i] = int(helixIndexes[i])\n",
    "\n",
    "        for (index, r) in zip(helixIndexes, replace):  # replacing the list of dashes(seq3D) which represents the sequence with helix symbols, where they are occuring\n",
    "            seq3D[index-1] = r\n",
    "        sequence3d= \"\".join(seq3D)\n",
    "\n",
    "\n",
    "        # SHEEET | representation\n",
    "\n",
    "        with open(load_file, 'r') as f:         # we use the three lists from the that heve undergone helix procesing i.e we append the sheet symbols and lables to them\n",
    "            sheetIndex = []                     # we start and empty list for the sheet indexes\n",
    "            lablesSheet = []                          # for appending lables for the sheet\n",
    "            lableIndexesSheets = []                    # for appending indexes for labling\n",
    "            for line in f:\n",
    "                if line.startswith('SHEET'):\n",
    "                    l = line.split()[1:]            # split our lines into a list with individual items that we can easily access\n",
    "                    if l[4] == chain:\n",
    "                        start = int(l[5])                            # Extract the start sequence index from the pdb\n",
    "                        end = int(l[8])                              # Extract the end index for the sheet from the pdb file\n",
    "                        lableIndexesSheets.append(start)             # append the indexes that will  mark  the point the sheet is starting\n",
    "                        lablesSheet.append((str(l[0])+(str(l[1]))))  # appends the lable for all the helixes on alist\n",
    "\n",
    "                        for i in range(start,end+1):                 # using the range extracted above prints in to the list all the indexes of the aa in that sheet to a list\n",
    "                            sheetIndex.append(i)\n",
    "            else:\n",
    "                pass\n",
    "\n",
    "        for i in range(0,len(lableIndexesSheets)):         # convert the values on the LableIndex list into integers\n",
    "            lableIndexesSheets[i] = int(lableIndexesSheets[i])\n",
    "\n",
    "        for (index, labl) in zip(lableIndexesSheets, lablesSheet): # Replacing the lable3D list at the specific indexes with the lables\n",
    "            if len(labl) > 1:                                      # if the lable has more lab one character we want to make the two characters to be read as one\n",
    "                lable3D[index-1:index+len(labl)-1] =labl\n",
    "            else:\n",
    "                lable3D[index-1] = labl                   \n",
    "        lablerSheet = (\"\".join(lable3D))    \n",
    "\n",
    "        sheetReplacer = []                                    # creating a string containg the symbols for sheet for each index for the index list created before(sheetIndex)\n",
    "        for i in range(0, len(sheetIndex)+1):\n",
    "            sheetReplacer.append(\"|\")\n",
    "\n",
    "        for i in range(0,len(sheetIndex)):            # convertring items in the list in to integers\n",
    "            sheetIndex[i] = int(sheetIndex[i])\n",
    "\n",
    "        for (index, r) in zip(sheetIndex, sheetReplacer):  # replacing the list of dashes(seq3D) which represents the sequence with helix symbols, where they are occuring\n",
    "            seq3D[index-1] = r\n",
    "        sequence3dSheet = \"\".join(seq3D)\n",
    "\n",
    "\n",
    "        def print80char(seq, seqSymbols, seqLables):\n",
    "            \"\"\"Input: Amino acid string sequence, Amino acid string with symbols, Amino acid string of sequence lables\n",
    "               Function: prints 80 characters of the three seqences in tandem        \n",
    "            \"\"\"\n",
    "            print(\"Chain %s:\\n(1)\"%chain)\n",
    "            for c in range(0,len(seq),80):\n",
    "                print(seq[c:c+80]+\"\\n\"+ seqSymbols[c:c+80]+\"\\n\"+seqLables[c:c+80]+\"\\n\")\n",
    "                \n",
    "        print80char(seq,sequence3dSheet,lablerSheet)\n",
    "        print(\"(%d)\"%len(seq),\"\\n\")                     # print length of the sequence\n",
    "\n",
    "\n",
    "\n",
    "    aa_dic = {'A':'ALA', 'R':'ARG', 'N':'ASN', 'D':'ASP', 'G':'GLY', 'Q':'GLN', 'E':'GLU', 'H':'HIS','C':'CYS',\\\n",
    "              'I':'ILE', 'L':'LEU', 'K':'LYS', 'M':'MET', 'F':'PHE', 'P':'PRO', 'S':'SER', 'T':'THR', 'W':'TRP', 'Y':'TYR', 'V':'VAL'} # dictionary for amino acids\n",
    "    new_dict = dict([(value, key) for (key, value) in aa_dic.items()]) # swapped the values and keys \n",
    "\n",
    "\n",
    "    with open(load_file, 'r') as f:\n",
    "        chains = []\n",
    "        for line in f:\n",
    "            if line.startswith('SEQRES'):\n",
    "                l = line.split()[2:]         \n",
    "                chains.append(l[0])                     # Appends all the chains found on the chain identifier column to an empty list\n",
    "                chains = (list(dict.fromkeys(chains)))  # removes repeated chain names to remain with only individual chain names\n",
    "\n",
    "        for i in chains:\n",
    "            seq = \"\"\n",
    "            with open(load_file, 'r') as f:\n",
    "                for line in f:\n",
    "                    l = line.split()\n",
    "                    if line.startswith('SEQRES')and i == l[2]:\n",
    "                        l = l[4:]\n",
    "                        c = [new_dict[codon]for codon in l]\n",
    "                        seq += \"\".join(c)\n",
    "            seq_helix_sheet3D(load_file,seq,i)\n",
    "        menu()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CHOICE X - Export pdb\n",
    "def choiceX():\n",
    "    \"\"\"Function: Exports your file to a pdb file\"\"\"\n",
    "    exported = input(\"Enter the file path and name you want to export including the '.pdb' extension: \")\n",
    "    with open(load_file) as f:\n",
    "        with open(exported, \"w+\") as fx:\n",
    "            for line in f:\n",
    "                fx.write(line) \n",
    "    menu()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m\u001b[0m \u001b[0;34mPDB FILE ANALYZER\u001b[0m                                                           \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m  \u001b[0;34mSelect an option from below:\u001b[0m                                                \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m                                                                            \u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m1) Open a PDB file                     (O)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m2) Information                         (I)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m3) Show histrogram of amino acids      (H)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m4) Display Secondary Structure         (S)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m5) Export PDB File                     (X)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m6) Exit                                (Q)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m                                                            \u001b[0;34mCurrent PDB: None\u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      ":\n",
      "\u001b[0;31mInvalid choice!\n",
      "Enter a valid choice ie 'o' to load a pdb file or 'q' to Exit the program \u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m\u001b[0m \u001b[0;34mPDB FILE ANALYZER\u001b[0m                                                           \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m  \u001b[0;34mSelect an option from below:\u001b[0m                                                \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m                                                                            \u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m1) Open a PDB file                     (O)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m2) Information                         (I)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m3) Show histrogram of amino acids      (H)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m4) Display Secondary Structure         (S)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m5) Export PDB File                     (X)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m6) Exit                                (Q)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m                                                            \u001b[0;34mCurrent PDB: None\u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      ":o\n",
      "Enter a Valid PATH for a PDB File:../Data/3AYU.pdb\n",
      "\u001b[0;31mThe File ../Data/3AYU.pdb has been sucessfully loaded\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m\u001b[0m \u001b[0;34mPDB FILE ANALYZER\u001b[0m                                                           \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m  \u001b[0;34mSelect an option from below:\u001b[0m                                                \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m                                                                            \u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m1) Open a PDB file                     (O)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m2) Information                         (I)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m3) Show histrogram of amino acids      (H)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m4) Display Secondary Structure         (S)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m5) Export PDB File                     (X)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m6) Exit                                (Q)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m                                                        \u001b[0;34mCurrent PDB: 3AYU.pdb\u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      ":i\n",
      "PDB File: \u001b[0;31m3AYU.pdb\u001b[0m \n",
      "Title: CRYSTAL STRUCTURE OF MMP-2 ACTIVE SITE MUTANT IN COMPLEX WITH APP-2 DRIVE\n",
      "D DECAPEPTIDE INHIBITOR\n",
      "Chains: A and B\n",
      " - Chain A\n",
      "     Number of amino acids:  164\n",
      "     Number of helix:         3\n",
      "     Number of sheet:         9\n",
      "     Sequence: YNFFPRKPKWDKNQITYRIIGYTPDLDPETVDDAFARAFQVWSDVTPLRF\n",
      "               SRIHDGEADIMINFGRWEHGDGYPFDGKDGLLAHAFAPGTGVGGDSHFDD\n",
      "               DELWTLGKGVGYSLFLVAAHAFGHAMGLEHSQDPGALMAPIYTYTKNFRL\n",
      "               SQDDIKGIQELYGASPD\n",
      " - Chain B\n",
      "     Number of amino acids:  10\n",
      "     Number of helix:         0\n",
      "     Number of sheet:         1\n",
      "     Sequence: ISYGNDALMP\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m\u001b[0m \u001b[0;34mPDB FILE ANALYZER\u001b[0m                                                           \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m  \u001b[0;34mSelect an option from below:\u001b[0m                                                \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m                                                                            \u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m1) Open a PDB file                     (O)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m2) Information                         (I)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m3) Show histrogram of amino acids      (H)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m4) Display Secondary Structure         (S)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m5) Export PDB File                     (X)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m6) Exit                                (Q)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m                                                        \u001b[0;34mCurrent PDB: 3AYU.pdb\u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      ":h\n",
      "\u001b[0;34mChoose an option to order by:\u001b[0m\n",
      "\u001b[0;34m   number of amino acids - ascending  (an)\u001b[0m\n",
      "\u001b[0;34m   number of amino acids - descending (dn)\u001b[0m\n",
      "\u001b[0;34m   alphabetically - ascending         (aa)\u001b[0m\n",
      "\u001b[0;34m   alphabetically - descending        (da)\u001b[0m\n",
      "Order by:an\n",
      "ASP ( 20) : ********************\n",
      "GLY ( 20) : ********************\n",
      "ALA ( 15) : ***************\n",
      "LEU ( 13) : *************\n",
      "PHE ( 12) : ************\n",
      "PRO ( 11) : ***********\n",
      "ILE ( 10) : **********\n",
      "TYR (  9) : *********\n",
      "THR (  8) : ********\n",
      "SER (  8) : ********\n",
      "ARG (  7) : *******\n",
      "LYS (  7) : *******\n",
      "HIS (  7) : *******\n",
      "GLU (  6) : ******\n",
      "VAL (  6) : ******\n",
      "ASN (  5) : *****\n",
      "GLN (  5) : *****\n",
      "TRP (  4) : ****\n",
      "MET (  4) : ****\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m\u001b[0m \u001b[0;34mPDB FILE ANALYZER\u001b[0m                                                           \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m  \u001b[0;34mSelect an option from below:\u001b[0m                                                \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m                                                                            \u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m1) Open a PDB file                     (O)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m2) Information                         (I)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m3) Show histrogram of amino acids      (H)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m4) Display Secondary Structure         (S)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m5) Export PDB File                     (X)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m6) Exit                                (Q)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m                                                        \u001b[0;34mCurrent PDB: 3AYU.pdb\u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ":s\n",
      "Secondary Structure of the PDB id ../Data/3AYU.pdb\n",
      "Chain A:\n",
      "(1)\n",
      "YNFFPRKPKWDKNQITYRIIGYTPDLDPETVDDAFARAFQVWSDVTPLRFSRIHDGEADIMINFGRWEHGDGYPFDGKDG\n",
      "-||----------||||||-------//////////////////----||||-------||||||---------------\n",
      " 1A          2B           1                     1B         3B                   \n",
      "\n",
      "LLAHAFAPGTGVGGDSHFDDDELWTLGKGVGYSLFLVAAHAFGHAMGLEHSQDPGALMAPIYTYTKNFRLSQDDIKGIQE\n",
      "--||||---------||||----||------||/////////////-||---------------------//////////\n",
      "  5B           4B      1C      2C2             2A                     3         \n",
      "\n",
      "LYGASPD\n",
      "///----\n",
      "       \n",
      "\n",
      "(167) \n",
      "\n",
      "Chain B:\n",
      "(1)\n",
      "ISYGNDALMP\n",
      "------||--\n",
      "      6B  \n",
      "\n",
      "(10) \n",
      "\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m\u001b[0m \u001b[0;34mPDB FILE ANALYZER\u001b[0m                                                           \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m  \u001b[0;34mSelect an option from below:\u001b[0m                                                \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m \u001b[0;34m                                                                            \u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m1) Open a PDB file                     (O)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m2) Information                         (I)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m3) Show histrogram of amino acids      (H)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m4) Display Secondary Structure         (S)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m5) Export PDB File                     (X)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m       \u001b[0;34m6) Exit                                (Q)\u001b[0m                             \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m*\u001b[0m                                                        \u001b[0;34mCurrent PDB: 3AYU.pdb\u001b[0m \u001b[0;34m*\u001b[0m\n",
      "\u001b[0;34m********************************************************************************\u001b[0m\n",
      ":q\n",
      "\u001b[0;31mDo you want to exit(E) or do you want go back to the menu (M)\u001b[0m\n",
      "e\n"
     ]
    },
    {
     "ename": "SystemExit",
     "evalue": "\u001b[0;31mGood bye! Thank you for using this sofware.\u001b[0m",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\u001b[0;31m:\u001b[0m \u001b[0;31mGood bye! Thank you for using this sofware.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "# Running the software\n",
    "def mainMenu():\n",
    "    \"\"\"Function: Runs the software by calling various defined functions for the different options and also the display of the software\"\"\"\n",
    "    import sys\n",
    "    red = lambda text: '\\033[0;31m' + text + '\\033[0m'\n",
    "    \n",
    "    global file\n",
    "    file= \"None\"\n",
    "    menu()                                              # The display function\n",
    "    \n",
    "    def choiceMenu():\n",
    "        \"\"\"Function: allows the diffrent options from the defined function to be accesed at any given time while running the software\"\"\"\n",
    "        \n",
    "        if choice.lower()== (\"i\"):                      #\n",
    "            choiceI()                       \n",
    "            choiceMenu()\n",
    "        if choice.lower() == (\"h\"):\n",
    "            choiceH()\n",
    "            choiceMenu()\n",
    "        if choice.lower() == (\"s\"):\n",
    "            choiceS(load_file)\n",
    "            choiceMenu()\n",
    "        if choice.lower()== (\"x\"):                      #\n",
    "            choiceX()\n",
    "            choiceMenu()\n",
    "        else:\n",
    "            if choice.lower() == \"o\":\n",
    "                print(\"Current loaded pdb file is %s\"%red(load_file),\"\\nDo you want to load another file (yes/no)\")\n",
    "                key = input()\n",
    "                if key.lower() == 'yes':\n",
    "                    mainMenu()\n",
    "                elif key.lower() == \"no\":\n",
    "                    pass\n",
    "                    menu()\n",
    "                    choiceMenu()\n",
    "                    \n",
    "            if choice.lower() == \"q\":\n",
    "                print(red(\"Do you want to exit(E) or do you want go back to the menu (M)\"))\n",
    "                select = input()\n",
    "                if select.lower() == \"e\":\n",
    "                    sys.exit(red(\"Good bye! Thank you for using this sofware.\"))\n",
    "                elif select.lower() == \"m\":\n",
    "                    mainMenu()\n",
    "                    \n",
    "            if choice.lower() not in ('o', 'i', 'h', 's', 'x', 'q'):\n",
    "                print(red(\"Invalid option selected\"))\n",
    "                menu()\n",
    "                mainMenu()\n",
    "\n",
    "    if choice.lower() in ('o', 'i', 'h', 's', 'x', 'q'):\n",
    "        if choice.lower() == \"o\":\n",
    "            choiceO()\n",
    "            choiceMenu()\n",
    "\n",
    "        if choice.lower() == \"q\":\n",
    "            print(red(\"Do you want to exit(E) or do you want go back to the menu (M)\"))\n",
    "            select = input()\n",
    "            if select.lower() == \"e\":\n",
    "                sys.exit(red(\"Good bye! Thank you for using this sofware.\"))\n",
    "            elif select.lower() == \"m\":\n",
    "                mainMenu()         \n",
    "    else:\n",
    "        print(red(\"Invalid choice!\\nEnter a valid choice ie 'o' to load a pdb file or 'q' to Exit the program \"))\n",
    "        mainMenu()\n",
    "\n",
    "mainMenu()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "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
}