reimplementation

big changes,
GUI added

Author: hoerldavid

CUTable.py

@@ -0,0 +1,112 @@
+'''
+Created on 08.02.2015
+
+@author: david
+'''
+
+from Bio.Data.CodonTable import standard_dna_table
+from Bio.Seq import Seq
+
+class CUTable(object):
+    '''
+    classdocs
+    '''
+
+
+    def __init__(self, SPSUM_LABEL, spsum, code=standard_dna_table):
+        '''
+        Constructor
+        SPSUM_LABEL is a string of whitespace separated codons
+        spsusm is a string of whitespace separated numbers(frequencies)
+        as present in the .spsum files of Kazusa
+        Code is a Biopython codon-table object (TODO?: only standard at the moment)
+        '''
+        
+        # codon >> aa map
+        self.codon2AA = dict()
+        # aa >> (codon, freq) list
+        self.aa2CodonAndFreq = dict()
+        
+        labels = SPSUM_LABEL.split(" ")
+        freqs = spsum.split(" ")
+        
+        for i in range(len(labels)):
+            ## RNA labels to DNA labels
+            lt = Seq(labels[i]).back_transcribe()
+            labels[i] = str(lt)
+            
+            ## convert frequencies to ints
+            freqs[i] = int(freqs[i])
+            
+        #print(code.forward_table)
+        
+        for i in range(len(labels)):
+            if labels[i] in code.stop_codons:
+                self.codon2AA[labels[i]] = 'STOP'
+            else:
+                self.codon2AA[labels[i]] = code.forward_table[labels[i]]
+              
+            tAA = self.codon2AA[labels[i]]
+            if not self.aa2CodonAndFreq.get(tAA):
+                self.aa2CodonAndFreq[tAA] = list()
+            
+            self.aa2CodonAndFreq[tAA].append((labels[i], freqs[i]))
+        
+        #print(self.codon2AA)
+        #print(self.aa2CodonAndFreq)
+        
+    def print(self):
+        '''
+        print a (relatively) readable vesion of the CUTable to stdout
+        '''
+        for k, v in self.aa2CodonAndFreq.items():
+            print(k + ":")
+            for cd, fr in self.getCodonsForAA(k):
+                print("\t" + cd + ": " + str(fr))
+    
+    def getAAForCodon(self, codon):
+        '''
+        get the AA corresponding to codon
+        '''
+        return self.codon2AA[codon]
+    
+    def getCodonRelativeUsage(self, codon):
+        aa = self.codon2AA[codon]
+        for cd, fr in self.getCodonsForAARelative(aa):
+            if cd == codon:
+                return fr
+        
+    def getCodonUsage(self, codon):
+        aa = self.codon2AA[codon]
+        for cd, fr in self.getCodonsForAA(aa):
+            if cd == codon:
+                return fr
+            
+    def getCodonsForAA(self, aa):
+        '''
+        get a list of (codon, rel. usage) for all codons coding for aa
+        '''
+        res = list()
+        sumFr = 0
+        for cd, fr in self.aa2CodonAndFreq[aa]:
+            sumFr += fr
+            
+        for cd, fr in self.aa2CodonAndFreq[aa]:
+            res.append((cd, fr/sumFr))
+        
+        return res
+    
+    def getCodonsForAARelative(self, aa):
+        '''
+        get a list of (codon, rel. usage %of max) for all codons coding for aa
+        '''
+        res = list()
+        maxFr = 0
+        for cd, fr in self.aa2CodonAndFreq[aa]:
+            if fr > maxFr:
+                maxFr = fr
+            
+        for cd, fr in self.aa2CodonAndFreq[aa]:
+            res.append((cd, fr/maxFr))
+        
+        return res

KazusaSPSUMHandler.py

@@ -0,0 +1,95 @@
+'''
+Created on 07.02.2015
+
+@author: david
+'''
+
+from os import listdir
+from os.path import join
+
+from CUTable import CUTable
+
+class KazusaSPSUMHandler(object):
+    '''
+    classdocs
+    '''
+
+
+    def __init__(self, path=""):
+        '''
+        Constructor
+        '''
+        
+        self.taxidToCodonUsage = dict()
+        self.descToTaxidAndNCDS = dict()
+
+        if not path:
+            pass
+        else:
+            self.loadSPSUMFromPath(path)
+        
+        
+    def loadSPSUMFromPath(self, path):
+        '''
+        
+        '''
+        
+        files = listdir(path)
+        
+        for f in files:
+            if f.endswith(".spsum"):
+                self.readSPSUMFile(join(path, f))
+            elif f == "SPSUM_LABEL":
+                self.readSPSUM_LABEL(join(path, f))
+        
+        
+    def readSPSUMFile(self, file):
+        fd = open(file)
+        
+        while True:
+            
+            descLine = fd.readline()
+            if not descLine: break
+            
+            cu = fd.readline()
+            
+            # split into taxid:desc:nrCDS
+            taxid = descLine.split(":", 1)[0].strip()
+            desc = descLine.split(":", 1)[1].strip()
+            ncds = desc.rsplit(":", 1)[1].strip()
+            desc = desc.rsplit(":", 1)[0].strip()
+            
+            self.taxidToCodonUsage[taxid] = cu.strip()
+            self.descToTaxidAndNCDS[desc] = (taxid, ncds)
+            
+        fd.close()
+        
+    def readSPSUM_LABEL(self, file):
+        
+        fd = open(file)
+        fd.readline() # omit first line
+        
+        self.SPSUM_LABEL = fd.readline().strip()
+        
+        fd.close()
+    
+        
+    def search(self, query):
+        '''
+        '''
+        
+        res = dict()
+        
+        for desc, taxidNCS in self.descToTaxidAndNCDS.items():
+            if desc.find(query) != -1:
+                res[desc] = taxidNCS
+                
+        return res
+        
+    def getCUTable(self, taxid):
+        '''
+        '''
+        res = CUTable(self.SPSUM_LABEL, self.taxidToCodonUsage[taxid])
+        return res
+        
+        

OptimizerApp.py

@@ -0,0 +1,128 @@
+'''
+Created on 14.02.2015
+
+@author: David
+'''
+from KazusaSPSUMHandler import KazusaSPSUMHandler
+from codonoptimizer import *
+from Bio.Restriction.Restriction_Dictionary import rest_dict
+from Bio.Seq import Seq
+
+import configparser
+
+class OptimizerApp:
+    '''
+    classdocs
+    '''
+
+
+    def __init__(self, config=None):
+        '''
+        Constructor
+        '''
+        self.restrictionEnzymeList = list()
+        self.speciesList = list()
+        self.SPSUMHandler = KazusaSPSUMHandler("res")
+        
+        if config:
+            self.loadConfig(config)
+        
+        self.possibleOptimizationStrategies = ["Fastest Codons", "Adapt Speed To Source"]
+        self.optimizer = None
+        
+#         self.speciesList.append(("1234", "Testus specius"))
+        
+        self.sourceSequence = ""
+        self.optimizedSequence = ""
+        
+    def setOptimizer(self, sourceTaxid, targetTaxid, strategy):
+        
+        if not strategy in self.possibleOptimizationStrategies:
+            return
+        
+        if strategy == "Fastest Codons":
+            self.optimizer = MostFrequentCodonOptimizer(self.SPSUMHandler.getCUTable(sourceTaxid), self.SPSUMHandler.getCUTable(targetTaxid))
+        elif strategy == "Adapt Speed To Source":
+            self.optimizer = AdaptingCodonOptimizer(self.SPSUMHandler.getCUTable(sourceTaxid), self.SPSUMHandler.getCUTable(targetTaxid))
+        else:
+            return
+        
+    def setSourceSeq(self, seq):
+        self.sourceSequence = seq.upper()
+        
+    def setOptimizedSeq(self, seq):
+        self.optimizedSequence = seq.upper()
+        
+    def runOptimization(self):
+        self.optimizedSequence = self.optimizer.getBestSequence(self.sourceSequence)
+#         print("optimized to: " + self.optimizedSequence)
+        assert Seq(self.sourceSequence).translate() == Seq(self.optimizedSequence).translate()
+        
+    def runRestricionRemoval(self):
+        restrictionSequences = list()
+        for r in self.restrictionEnzymeList:
+            restrictionSequences.append(rest_dict[r]['site'])
+        self.optimizedSequence = self.optimizer.removeRestrictionSites(self.sourceSequence, self.optimizedSequence, restrictionSequences)
+        assert Seq(self.sourceSequence).translate() == Seq(self.optimizedSequence).translate()
+        
+    def getCodonsForPrint(self, source=True):
+        if self.optimizer:
+            restrictionSequences = list()
+            for r in self.restrictionEnzymeList:
+                restrictionSequences.append(rest_dict[r]['site'])
+            
+            if source:
+                return self.optimizer.SequenceToPrint(self.sourceSequence, restrictionSequences, source)
+            else:
+                return self.optimizer.SequenceToPrint(self.optimizedSequence, restrictionSequences, source)
+            
+        else:
+            return None
+        
+    def testPrint(self):
+        print(self.optimizer)
+        print(self.sourceSequence)
+        
+    def saveConfig(self, path):
+        cp = configparser.ConfigParser()
+        taxids = list()
+        names = list()
+        for t, s in self.speciesList:
+            taxids.append(t)
+            names.append(s)
+        restrictionEnzymes = list()
+        for r in self.restrictionEnzymeList:
+            restrictionEnzymes.append(r)
+         
+        cp['config'] = {"speciesTaxids" : ",".join(taxids), "speciesNames" : ",".join(names), "restrictionEnzymes" :",".join(restrictionEnzymes)}
+        with open(path, 'w') as configfile:
+#             print("writing config")
+            cp.write(configfile)
+        
+    def loadConfig(self, path):
+        cp = configparser.ConfigParser()
+        cp.read(path)
+        
+        taxids = list()
+        for t in cp["config"]["speciesTaxids"].split(","):
+            if t:
+                taxids.append(t)
+            
+        names = list()
+        for n in cp["config"]["speciesNames"].split(","):
+            if n:
+                names.append(n)
+            
+        restrictionEnzymes = list()
+        for r in cp["config"]["restrictionEnzymes"].split(","):
+            if r:
+                restrictionEnzymes.append(r)
+            
+        for i in range(len(taxids)):
+            self.speciesList.append((taxids[i], names[i]))
+            
+        self.restrictionEnzymeList = restrictionEnzymes
+        
+    def setTest(self):
+        self.sourceSequence = "ATGC"  
+        

OptimizerMain.py

@@ -0,0 +1,19 @@
+'''
+Created on 14.02.2015
+
+@author: David
+'''
+from OptimizerApp import OptimizerApp
+from OptimizerMainWindow import OptimizerMainWindow
+import SeqUtils
+
+
+if __name__ == '__main__':
+    
+#     print(SeqUtils.getRemainderSuffix("AAAACCA"))
+    
+    myOptimizer = OptimizerApp("config.ini")
+    myOptimizerGUI = OptimizerMainWindow(myOptimizer)
+#     gui = Tk()
+#     gui.mainloop()
+#     myOptimizer.testPrint()