2to3 converted FRED2 package

Fred2/CleavagePrediction/External.py

@@ -73,7 +73,7 @@ def predict(self, aa_seq, command=None, options=None, **kwargs):
         result = {}
         peps = list(pep_seqs.values())
 
-        for i in xrange(0, len(peps), chunksize):
+        for i in range(0, len(peps), chunksize):
             tmp_out = NamedTemporaryFile(delete=False)
             tmp_file = NamedTemporaryFile(delete=False)
             self.prepare_input(peps[i:i+chunksize], tmp_file)
@@ -120,7 +120,7 @@ class NetChop_3_1(AExternalCleavageSitePrediction, AExternal):
         T-cell epitopes: insights obtained from improved predictions of proteasomal cleavage.
         Immunogenetics, 57(1-2), 33-41.
     """
-    __supported_length = [sys.maxint]
+    __supported_length = [sys.maxsize]
     __name = "netchop"
     __cleavage_pos = 0
     __command = "netchop {input} {options} | grep -v '#' > {out}"
@@ -260,7 +260,7 @@ def predict(self, aa_seq, command=None, options=None, **kwargs):
         result = {}
         peps = list(pep_seqs.items())
 
-        for i in xrange(0, len(peps), chunksize):
+        for i in range(0, len(peps), chunksize):
 
             tmp_out = NamedTemporaryFile(delete=False)
             tmp_file = NamedTemporaryFile(delete=False)

Fred2/CleavagePrediction/PSSM.py

@@ -66,7 +66,7 @@ def __load_model(length):
             raise KeyError("No model found for %s with length %i"%(self.name, length))
 
         diff = length - self.cleavagePos
-        for j,seq in enumerate(pep_seqs.iterkeys()):
+        for j,seq in enumerate(pep_seqs.keys()):
 
             seq_id = "seq_%i"%j
             p = pep_seqs[seq]
@@ -75,7 +75,7 @@ def __load_model(length):
                 if p.transcript_id:
                     seq_id = p.transcript_id
             else:
-                for t in p.proteins.iterkeys():
+                for t in p.proteins.keys():
                     if t:
                         seq_id = t
                         break
@@ -85,7 +85,7 @@ def __load_model(length):
                 warnings.warn("Sequence length of %i is to small for specified window of %i"%(len(seq),length), RuntimeWarning)
                 continue
 
-            for i in xrange(len(seq)):
+            for i in range(len(seq)):
                 if i < (length-1):
 
                     result["Seq"][(seq_id, i)] = seq[i]
@@ -332,7 +332,7 @@ def __load_model(length):
                 pep_seqs[str(p)] = p
 
         result = {self.name:{}}
-        for length, peps in itertools.groupby(pep_seqs.iterkeys(), key= lambda x: len(x)):
+        for length, peps in itertools.groupby(iter(pep_seqs.keys()), key= lambda x: len(x)):
             peps = list(peps)
             #dynamicaly import prediction PSSMS for alleles and predict
             if length not in self.supportedLength:
@@ -438,7 +438,7 @@ def __load_model(length):
                 pep_seqs[str(p)] = p
 
         result = {self.name: {}}
-        for length, peps in itertools.groupby(pep_seqs.iterkeys(), key=lambda x: len(x)):
+        for length, peps in itertools.groupby(iter(pep_seqs.keys()), key=lambda x: len(x)):
             peps = list(peps)
             #dynamicaly import prediction PSSMS for alleles and predict
             if length not in self.supportedLength:

Fred2/CleavagePrediction/__init__.py

@@ -48,7 +48,7 @@ def available_methods():
 
         :return: dict(str,list(int)) - dict of cleavage site predictor represented as string and the supported versions
         """
-        return {k: sorted(versions.iterkeys()) for k, versions in ACleavageSitePrediction.registry.iteritems()}
+        return {k: sorted(versions.keys()) for k, versions in ACleavageSitePrediction.registry.items()}
 
 
 class CleavageFragmentPredictorFactory(object):
@@ -80,4 +80,4 @@ def available_methods():
 
         :return: dict(str,list(str)) - dict of cleavage site predictor represented as string and the supported versions
         """
-        return {k: sorted(versions.iterkeys()) for k, versions in ACleavageFragmentPrediction.registry.iteritems()}
+        return {k: sorted(versions.keys()) for k, versions in ACleavageFragmentPrediction.registry.items()}

Fred2/Core/Allele.py

@@ -22,11 +22,10 @@ def __call__(cls, name, prob=None):
         return type.__call__(cls, name, prob=prob)
 
 
-class Allele(MetadataLogger):
+class Allele(MetadataLogger, metaclass=AlleleFactory):
     """
     This class represents an HLA Allele and stores additional information
     """
-    __metaclass__ = AlleleFactory
 
     def __init__(self, name, prob=None):
         """

Fred2/Core/Base.py

@@ -86,17 +86,15 @@ def __getitem__(cls, args):
         return cls.registry[name][version]
 
     def __iter__(cls):
-        return iter(cls.registry.values())
+        return iter(list(cls.registry.values()))
 
     def __str__(cls):
         if cls in cls.registry:
             return cls.__name__
         return cls.__name__ + ": " + ", ".join([sc.__name__ for sc in cls])
 
 
-class ACleavageSitePrediction(object):
-    __metaclass__ = APluginRegister
-
+class ACleavageSitePrediction(object, metaclass=APluginRegister):
     @abc.abstractproperty
     def name(self):
         """
@@ -140,9 +138,7 @@ def predict(self, aa_seq, **kwargs):
         raise NotImplementedError
 
 
-class ACleavageFragmentPrediction(object):
-    __metaclass__ = APluginRegister
-
+class ACleavageFragmentPrediction(object, metaclass=APluginRegister):
     @abc.abstractproperty
     def name(self):
         """
@@ -185,9 +181,7 @@ def predict(self, aa_seq, **kwargs):
         raise NotImplementedError
 
 
-class AEpitopePrediction(object):
-    __metaclass__ = APluginRegister
-
+class AEpitopePrediction(object, metaclass=APluginRegister):
     @abc.abstractproperty
     def name(self):
         """
@@ -246,11 +240,10 @@ def predict(self, peptides, alleles=None, **kwargs):
         raise NotImplementedError
 
 
-class ASVM(object):
+class ASVM(object, metaclass=abc.ABCMeta):
     """
         Base class for SVM prediction tools
     """
-    __metaclass__ = abc.ABCMeta
 
     @abc.abstractmethod
     def encode(self, peptides):
@@ -265,11 +258,10 @@ def encode(self, peptides):
         raise NotImplementedError
 
 
-class AExternal(object):
+class AExternal(object, metaclass=abc.ABCMeta):
     """
      Base class for external tools
     """
-    __metaclass__ = abc.ABCMeta
 
     @abc.abstractproperty
     def command(self):
@@ -333,9 +325,7 @@ def get_external_version(self, path=None):
         return str(stdo).strip()
 
 
-class ATAPPrediction(object):
-    __metaclass__ = APluginRegister
-
+class ATAPPrediction(object, metaclass=APluginRegister):
     @abc.abstractproperty
     def name(self):
         """
@@ -371,9 +361,7 @@ def predict(self, peptides, **kwargs):
         raise NotImplementedError
 
 
-class AHLATyping(object):
-    __metaclass__ = APluginRegister
-
+class AHLATyping(object, metaclass=APluginRegister):
     @abc.abstractproperty
     def name(self):
         """

Fred2/Core/Generator.py

@@ -235,11 +235,11 @@ def _generate_combinations(tId, vs, seq, usedVs, offset, isReverse):
 
     transToVar = {}
     for v in vars:
-        for trans_id in v.coding.iterkeys():
+        for trans_id in v.coding.keys():
             transToVar.setdefault(trans_id, []).append(v)
 
     prots = []
-    for tId, vs in transToVar.iteritems():
+    for tId, vs in transToVar.items():
         #print tId
         query = dbadapter.get_transcript_information(tId, type=id_type, _db=db)
         if query is None:
@@ -258,21 +258,21 @@ def _generate_combinations(tId, vs, seq, usedVs, offset, isReverse):
             continue
 
         generate_peptides_from_variants.transOff = 0
-        for start in xrange(0, len(tSeq) + 1 - 3 * length, 3):
+        for start in range(0, len(tSeq) + 1 - 3 * length, 3):
             #supoptimal as it always has to traverse the combination tree for all frameshift mutations.
             end = start + 3 * length
-            vars_fs_hom = filter(lambda x: (x.isHomozygous
+            vars_fs_hom = [x for x in vs if (x.isHomozygous
                                     or x.type in [VariationType.FSINS, VariationType.FSDEL])
-                                    and x.coding[tId].tranPos < start, vs)
-            vars_in_window = filter(lambda x: start <= x.coding[tId].tranPos < end, vs)
+                                    and x.coding[tId].tranPos < start]
+            vars_in_window = [x for x in vs if start <= x.coding[tId].tranPos < end]
 
             if vars_in_window:
                 vars = vars_fs_hom+vars_in_window
                 for ttId, varSeq, varComb in _generate_combinations(tId, vars, list(tSeq), {}, 0, strand == REVERS):
                     prots = chain(prots, generate_proteins_from_transcripts(Transcript("".join(varSeq), geneid, ttId,
                                                                                        vars=varComb)))
     return [ p for p in generate_peptides_from_proteins(prots, length, peptides=peptides)
-             if any(p.get_variants_by_protein(prot) for prot in p.proteins.iterkeys())]
+             if any(p.get_variants_by_protein(prot) for prot in p.proteins.keys())]
 
 ################################################################################
 #        V A R I A N T S     = = >    T R A N S C R I P T S
@@ -343,10 +343,10 @@ def _generate_combinations(tId, vs, seq, usedVs, offset, isReverse=False):
 
     transToVar = {}
     for v in vars:
-        for trans_id in v.coding.iterkeys():
+        for trans_id in v.coding.keys():
             transToVar.setdefault(trans_id, []).append(v)
 
-    for tId, vs in transToVar.iteritems():
+    for tId, vs in transToVar.items():
         query = dbadapter.get_transcript_information(tId, type=id_type, _db=db)
         if query is None:
             warnings.warn("Transcript with ID %s not found in DB"%tId)
@@ -414,7 +414,7 @@ def generate_proteins_from_transcripts(transcripts, table='Standard', stop_symbo
             prot_seq = str(t.translate(table=table, stop_symbol=stop_symbol, to_stop=to_stop, cds=cds))
 
             new_vars = dict()
-            for pos, var in t.vars.iteritems():
+            for pos, var in t.vars.items():
                 if not var.isSynonymous:
                     prot_pos = pos // 3
                     new_vars.setdefault(prot_pos, []).append(var)
@@ -450,7 +450,7 @@ def gen_peptide_info(protein):
         res = []
 
         seq = str(protein)
-        for i in xrange(len(protein)+1-window_size):
+        for i in range(len(protein)+1-window_size):
             # generate peptide fragment
             end = i+window_size
             pep_seq = seq[i:end]
@@ -483,4 +483,4 @@ def gen_peptide_info(protein):
                 final_peptides[seq].proteins[t_id] = prot
                 final_peptides[seq].proteinPos[t_id].append(pos)
 
-    return final_peptides.itervalues()
+    return iter(final_peptides.values())

Fred2/Core/Peptide.py

@@ -40,12 +40,12 @@ def __init__(self, seq, protein_pos=None):
 
         # Enforce dict storage
         if protein_pos and \
-                any(not isinstance(p, Protein) or any(not isinstance(i, (int, long)) for i in pos) for p, pos in
-                    protein_pos.iteritems()):
+                any(not isinstance(p, Protein) or any(not isinstance(i, int) for i in pos) for p, pos in
+                    protein_pos.items()):
             raise TypeError("The proteins_pos given to a Peptide object should be dict(Protein,list(int))")
-        self.proteins = dict() if protein_pos is None else {p.transcript_id:p for p in protein_pos.iterkeys()}
+        self.proteins = dict() if protein_pos is None else {p.transcript_id:p for p in protein_pos.keys()}
         self.proteinPos = collections.defaultdict(list) if protein_pos is None else {p.transcript_id: pos for p, pos in
-                                                                                     protein_pos.iteritems()}
+                                                                                     protein_pos.items()}
 
     def __getitem__(self, index):
         """
@@ -67,7 +67,7 @@ def __getitem__(self, index):
             start, stop, step = index.indices(len(self))
             if start > stop:
                 raise ValueError("start has to be greater than stop")
-            protPos = {self.proteins[tId]: [p+(start-p) for p in pos] for tId, pos in self.proteinPos.iteritems()}
+            protPos = {self.proteins[tId]: [p+(start-p) for p in pos] for tId, pos in self.proteinPos.items()}
             return Peptide(seq, protein_pos=protPos)
 
     def __repr__(self):
@@ -81,7 +81,7 @@ def __repr__(self):
                 lines.append("\tVARIANTS:")
                 for var in self.get_variants_by_protein(t_id):
                     lines.append("\t%s" % var)
-        for p in self.proteins.itervalues():
+        for p in self.proteins.values():
             p_id = p.transcript_id
             lines.append("in PROTEIN: %s" % p_id)
         return '\n'.join(lines)
@@ -94,7 +94,7 @@ def get_all_proteins(self):
         :return: A list of :class:`~Fred2.Core.Protein.Protein`
         :rtype: list(:class:`~Fred2.Core.Protein.Protein`)
         """
-        return self.proteins.values()
+        return list(self.proteins.values())
 
     def get_protein(self, transcript_id):
         """
@@ -115,7 +115,7 @@ def get_all_transcripts(self):
         :return: A list of :class:`~Fred2.Core.Transcript.Transcript`
         :rtype: list(:class:`~Fred2.Core.Transcript.Transcript`)
         """
-        return [p.orig_transcript for p in self.proteins.itervalues()]
+        return [p.orig_transcript for p in self.proteins.values()]
 
     def get_transcript(self, transcript_id):
         """
@@ -157,15 +157,15 @@ def get_variants_by_protein(self, transcript_id):
             fs = []
             shift = 0
             for start_pos in self.proteinPos[transcript_id]:
-                for i in xrange(start_pos):
+                for i in range(start_pos):
                     for v in p.vars.get(i, []):
                         if v.type in [VariationType.FSDEL, VariationType.FSINS]:
                             shift = (v.get_shift()+shift) % 3
                             if shift:
                                 fs.append(v)
                             else:
                                 fs = []
-                for j in xrange(start_pos, start_pos+len(self)):
+                for j in range(start_pos, start_pos+len(self)):
                     for v in p.vars.get(j, []):
                         var.append(v)
             fs.extend(var)
@@ -199,15 +199,15 @@ def get_variants_by_protein_position(self, transcript_id, protein_pos):
             var = dict()
             fs = dict()
             shift = 0
-            for i in xrange(protein_pos):
+            for i in range(protein_pos):
                 for v in p.vars.get(i, []):
                     if v.type in [VariationType.FSDEL, VariationType.FSINS]:
                         shift = (v.get_shift()+shift) % 3
                         if shift:
                             fs.setdefault(i - protein_pos, []).append(v)
                         else:
                             fs.clear()
-            for j in xrange(protein_pos, protein_pos+len(self)):
+            for j in range(protein_pos, protein_pos+len(self)):
                 for v in p.vars.get(j, []):
                     var.setdefault(j - protein_pos, []).append(v)
             fs.update(var)