ORForise 1.6.2__py3-none-any.whl

ORForise/Tools/GeneMark/GeneMark.py

@@ -0,0 +1,135 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+def GeneMark(*args):
+    tool_pred = args[0]
+    dna_regions = args[1]
+    if not dna_regions: # This triggers if dna_regions is an empty dict (GFF_Intersect passed nothing)
+        dna_regions = collections.OrderedDict()
+        with open(tool_pred, 'r') as GeneMark_input:
+            for line in GeneMark_input:
+                line = line.split()
+                if 'direct' in line[2] or 'complement' in line[2] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    geneMark_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        geneMark_ORFs[dna_region] = collections.OrderedDict()
+    for dna_region in dna_regions:
+        try:
+            genome = dna_regions[dna_region][0]
+        except IndexError:
+            genome = dna_regions[dna_region]
+        genome_size = len(genome)
+        genome_rev = revCompIterative(genome)
+        prev_Start = 0
+        prev_Stop = 0
+        started = False
+        with open(tool_pred, 'r') as GeneMark_input:
+            for line in GeneMark_input:
+                line = line.split()
+                if len(line) == 7:
+                    started = True
+                    if 'direct' in line[2] or 'complement' in line[2] and dna_region in line[0]:  # Strange Output requires strange code - We select the Longest ORF from each set
+                        start = int(line[0])
+                        stop = int(line[1])
+                        strand = line[2]
+                        if 'complement' in strand:  # Reverse Compliment starts and stops adjusted
+                            if start != prev_Start:
+                                r_start = genome_size - stop
+                                r_stop = genome_size - start
+                                strand = '-'
+                                startCodon = genome_rev[r_start:r_start + 3]
+                                stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+                                po = str(start) + ',' + str(stop)
+                                orf = [strand, startCodon, stopCodon, 'CDS', 'GeneMark']
+                                geneMark_ORFs.update({po: orf})
+                        elif 'direct' in strand:
+                            if stop != prev_Stop:
+                                startCodon = genome[start - 1:start + 2]
+                                stopCodon = genome[stop - 3:stop]
+                                strand = '+'
+                                po = str(start) + ',' + str(stop)
+                                orf = [strand, startCodon, stopCodon, 'CDS', 'GeneMark']
+                                geneMark_ORFs.update({po: orf})
+                        prev_Start = start
+                        prev_Stop = stop
+                elif len(line) == 0 and started == True:
+                    prev_Stop = 0
+                    prev_Start = 0
+
+    for group in geneMark_ORFs:
+        geneMark_ORFs[group] = sortORFs(geneMark_ORFs[group])
+    return geneMark_ORFs
+
+############# This section can be used to select the ORF with highest probability score.
+# with open('Tools/GeneMark/' + input_to_analyse, 'r') as GeneMark_input:
+#     prob_score = 0
+#     started = False
+#
+#     for line in GeneMark_input:
+#         line = line.split()
+#
+#         if len(line) == 7:
+#             if 'direct' in line[2] or 'complement' in line[2] and '....' not in line[6] : # Strange Output requires strange code
+#                 started = True
+#                 start = int(line[0])
+#                 stop = int(line[1])
+#                 score = float(line[5])
+#                 strand = line[2]
+#                 if 'complement' in strand:  # Reverse Compliment starts and stops to confirm to our definition
+#                     if start != prev_Start:
+#                         prob_score = score
+#                         # Switched to match Sense Strand
+#                         r_start = genome_size - stop
+#                         r_stop = genome_size - start
+#                         strand = '-'
+#                         startCodon = genome_rev[r_start:r_start + 3]
+#                         stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+#                         po = str(start) + ',' + str(stop)
+#                         orf = [strand, startCodon, stopCodon]
+#                     elif start == prev_Start and score > prob_score:
+#                         # Switched to match Sense Strand
+#                         prob_score = score
+#                         r_start = genome_size - stop
+#                         r_stop = genome_size - start
+#                         strand = '-'
+#                         startCodon = genome_rev[r_start:r_start + 3]
+#                         stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+#                         po = str(start) + ',' + str(stop)
+#                         orf = [strand, startCodon, stopCodon]
+#                 elif 'direct' in strand:
+#                     if stop != prev_Stop:
+#                         prob_score = score
+#                         startCodon = genome[start - 1:start - 1 + 3]
+#                         stopCodon = genome[stop - 3:stop - 1 + 1]
+#                         strand = '+'
+#                         po = str(start) + ',' + str(stop)
+#                         orf = [strand, startCodon, stopCodon]
+#                     elif stop == prev_Stop and score > prob_score:
+#                         prob_score = score
+#                         startCodon = genome[start - 1:start - 1 + 3]
+#                         stopCodon = genome[stop - 3:stop - 1 + 1]
+#                         strand = '+'
+#                         po = str(start) + ',' + str(stop)
+#                         orf = [strand, startCodon, stopCodon]
+#                 prev_Start = start
+#                 prev_Stop = stop
+#         elif len(line) == 0 and started == True:
+#             prob_score = 0
+#             prev_Start = 0
+#             prev_Stop = 0
+#             GeneMark_ORFs.update({po: orf})
+#             po = ''
+#             orf = []
+# #Remove last empty dict
+# del GeneMark_ORFs['']
+# print(GeneMark_ORFs)
+# return GeneMark_ORFs

ORForise/Tools/GeneMarkHA/GeneMarkHA.py

@@ -0,0 +1,54 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def GeneMark_HA(*args):
+    tool_pred = args[0]
+    dna_regions = args[1]
+    if not dna_regions: # This triggers if dna_regions is an empty dict (GFF_Intersect passed nothing)
+        dna_regions = collections.OrderedDict()
+        with open(tool_pred, 'r') as GeneMarkHA_input:
+            for line in GeneMarkHA_input:
+                line = line.split()
+                if len(line) >= 9 and "CDS" in line[5] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    geneMarkHA_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        geneMarkHA_ORFs[dna_region] = collections.OrderedDict()
+    for dna_region in dna_regions:
+        try:
+            genome = dna_regions[dna_region][0]
+        except IndexError:
+            genome = dna_regions[dna_region]
+        genome_size = len(genome)
+        genome_rev = revCompIterative(genome)
+        with open(tool_pred, 'r') as GeneMarkHA_input:
+            for line in GeneMarkHA_input:
+                line = line.split()
+                if len(line) >= 9 and "CDS" in line[5] and dna_region in line[0]:
+                    start = int(line[6])
+                    stop = int(line[7])
+                    strand = line[9]
+                    if '-' in strand:  # Reverse Compliment starts and stops adjusted
+                        r_start = genome_size - stop
+                        r_stop = genome_size - start
+                        startCodon = genome_rev[r_start:r_start + 3]
+                        stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+                    elif '+' in strand:
+                        startCodon = genome[start - 1:start + 2]
+                        stopCodon = genome[stop - 3:stop]
+                    po = str(start) + ',' + str(stop)
+                    orf = [strand, startCodon, stopCodon, 'CDS', 'GeneMarkHA']
+                    geneMarkHA_ORFs.update({po: orf})
+
+    for group in geneMarkHA_ORFs:
+        geneMarkHA_ORFs[group] = sortORFs(geneMarkHA_ORFs[group])
+    return geneMarkHA_ORFs

ORForise/Tools/GeneMarkHMM/GeneMarkHMM.py

@@ -0,0 +1,55 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+
+def GeneMark_HMM(*args):
+    tool_pred = args[0]
+    dna_regions = args[1]
+    if not dna_regions: # This triggers if dna_regions is an empty dict (GFF_Intersect passed nothing)
+        dna_regions = collections.OrderedDict()
+        with open(tool_pred, 'r') as GeneMarkHMM_input:
+            for line in GeneMarkHMM_input:
+                line = line.split()
+                if len(line) >= 9 and "CDS" in line[2] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    geneMarkHMM_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        geneMarkHMM_ORFs[dna_region] = collections.OrderedDict()
+    for dna_region in dna_regions:
+        try:
+            genome = dna_regions[dna_region][0]
+        except IndexError:
+            genome = dna_regions[dna_region]
+        genome_size = len(genome)
+        genome_rev = revCompIterative(genome)
+        with open(tool_pred, 'r') as GeneMarkHMM_input:
+            for line in GeneMarkHMM_input:
+                line = line.split('\t')
+                if len(line) >= 9 and "CDS" in line[2] and dna_region in line[0]:
+                    start = int(line[3])
+                    stop = int(line[4])
+                    strand = line[6]
+                    if '-' in strand:  # Reverse Compliment starts and stops adjusted
+                        r_start = genome_size - stop
+                        r_stop = genome_size - start
+                        startCodon = genome_rev[r_start:r_start + 3]
+                        stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+                    elif '+' in strand:
+                        startCodon = genome[start - 1:start + 2]
+                        stopCodon = genome[stop - 3:stop]
+                    po = str(start) + ',' + str(stop)
+                    orf = [strand, startCodon, stopCodon, 'CDS', 'GeneMarkHMM']
+                    geneMarkHMM_ORFs.update({po: orf})
+
+    for group in geneMarkHMM_ORFs:
+        geneMarkHMM_ORFs[group] = sortORFs(geneMarkHMM_ORFs[group])
+    return geneMarkHMM_ORFs

ORForise/Tools/GeneMarkS/GeneMarkS.py

@@ -0,0 +1,54 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def GeneMark_S(*args):
+    tool_pred = args[0]
+    dna_regions = args[1]
+    if not dna_regions: # This triggers if dna_regions is an empty dict (GFF_Intersect passed nothing)
+        dna_regions = collections.OrderedDict()
+        with open(tool_pred, 'r') as GeneMarkS_input:
+            for line in GeneMarkS_input:
+                line = line.split()
+                if len(line) >= 9 and "CDS" in line[5] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    geneMarkS_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        geneMarkS_ORFs[dna_region] = collections.OrderedDict()
+    for dna_region in dna_regions:
+        try:
+            genome = dna_regions[dna_region][0]
+        except IndexError:
+            genome = dna_regions[dna_region]
+        genome_size = len(genome)
+        genome_rev = revCompIterative(genome)
+        with open(tool_pred, 'r') as GeneMarkS_input:
+            for line in GeneMarkS_input:
+                line = line.split()
+                if len(line) >= 9 and "CDS" in line[5] and dna_region in line[0]:
+                    start = int(line[6])
+                    stop = int(line[7])
+                    strand = line[9]
+                    if '-' in strand:  # Reverse Compliment starts and stops adjusted
+                        r_start = genome_size - stop
+                        r_stop = genome_size - start
+                        startCodon = genome_rev[r_start:r_start + 3]
+                        stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+                    elif '+' in strand:
+                        startCodon = genome[start - 1:start + 2]
+                        stopCodon = genome[stop - 3:stop]
+                    po = str(start) + ',' + str(stop)
+                    orf = [strand, startCodon, stopCodon, 'CDS', 'GeneMarkS']
+                    geneMarkS_ORFs.update({po: orf})
+
+    for group in geneMarkS_ORFs:
+        geneMarkS_ORFs[group] = sortORFs(geneMarkS_ORFs[group])
+    return geneMarkS_ORFs

ORForise/Tools/GeneMarkS2/GeneMarkS2.py

@@ -0,0 +1,55 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def GeneMarkS2(*args):
+    tool_pred = args[0]
+    dna_regions = args[1]
+    if not dna_regions: # This triggers if dna_regions is an empty dict (GFF_Intersect passed nothing)
+        dna_regions = collections.OrderedDict()
+        with open(tool_pred, 'r') as GeneMarkS2_input:
+            for line in GeneMarkS2_input:
+                line = line.split()
+                if len(line) >= 9 and "CDS" in line[2] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    geneMarkS2_ORFs = collections.defaultdict()
+    for dna_region in dna_regions:
+        geneMarkS2_ORFs[dna_region] = collections.OrderedDict()
+    for dna_region in dna_regions:
+        try:
+            genome = dna_regions[dna_region][0]
+        except IndexError:
+            genome = dna_regions[dna_region]
+        genome_size = len(genome)
+        genome_rev = revCompIterative(genome)
+        with open(tool_pred, 'r') as GeneMarkS2_input:
+            for line in GeneMarkS2_input:
+                line = line.split('\t')
+                if len(line) >= 9 and dna_region in line[0] and "CDS" in line[2]:
+                    start = int(line[3])
+                    stop = int(line[4])
+                    strand = line[6]
+                    info = line[8]
+                    if '-' in strand:  # Reverse Compliment starts and stops adjusted
+                        r_start = genome_size - stop
+                        r_stop = genome_size - start
+                        startCodon = genome_rev[r_start:r_start + 3]
+                        stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+                    elif '+' in strand:
+                        startCodon = genome[start - 1:start + 2]
+                        stopCodon = genome[stop - 3:stop]
+                    po = str(start) + ',' + str(stop)
+                    orf = [strand, startCodon, stopCodon, 'CDS', 'GeneMarkS2']
+                    geneMarkS2_ORFs[dna_region].update({po: orf})
+
+    for group in geneMarkS2_ORFs:
+        geneMarkS2_ORFs[group] = sortORFs(geneMarkS2_ORFs[group])
+    return geneMarkS2_ORFs

ORForise/Tools/MetaGene/MetaGene.py

@@ -0,0 +1,54 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def MetaGene(*args):
+    tool_pred = args[0]
+    dna_regions = args[1]
+    if not dna_regions: # This triggers if dna_regions is an empty dict (GFF_Intersect passed nothing)
+        dna_regions = collections.OrderedDict()
+        with open(tool_pred, 'r') as MetaGene_input:
+            for line in MetaGene_input:
+                line = line.split()
+                if len(line) >= 6 and ("-" in line or '+' in line) and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    metaGene_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        metaGene_ORFs[dna_region] = collections.OrderedDict()
+    for dna_region in dna_regions:
+        try:
+            genome = dna_regions[dna_region][0]
+        except IndexError:
+            genome = dna_regions[dna_region]
+        genome_size = len(genome)
+        genome_rev = revCompIterative(genome)
+        with open(tool_pred, 'r') as MetaGene_input:
+            for line in MetaGene_input:
+                line = line.split()
+                if len(line) >= 6 and ("-" in line or '+' in line) and dna_region in line[0]:
+                    start = int(line[0])
+                    stop = int(line[1])
+                    strand = line[2]
+                    if '-' in strand:  # Reverse Compliment starts and stops adjusted
+                        r_start = genome_size - stop
+                        r_stop = genome_size - start
+                        startCodon = genome_rev[r_start:r_start + 3]
+                        stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+                    elif '+' in strand:
+                        startCodon = genome[start - 1:start + 2]
+                        stopCodon = genome[stop - 3:stop]
+                    po = str(start) + ',' + str(stop)
+                    orf = [strand, startCodon, stopCodon, 'CDS', 'MetaGene']
+                    metaGene_ORFs.update({po: orf})
+
+    for group in metaGene_ORFs:
+        metaGene_ORFs[group] = sortORFs(metaGene_ORFs[group])
+    return metaGene_ORFs

ORForise/Tools/MetaGeneAnnotator/MetaGeneAnnotator.py

@@ -0,0 +1,55 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def MetaGeneAnnotator(*args):
+    tool_pred = args[0]
+    dna_regions = args[1]
+    if not dna_regions: # This triggers if dna_regions is an empty dict (GFF_Intersect passed nothing)
+        dna_regions = collections.OrderedDict()
+        with open(tool_pred, 'r') as MetaGeneAnnotator_input:
+            for line in MetaGeneAnnotator_input:
+                line = line.split()
+                if len(line) == 11 and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    metaGeneAnnotator_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        metaGeneAnnotator_ORFs[dna_region] = collections.OrderedDict()
+    for dna_region in dna_regions:
+        try:
+            genome = dna_regions[dna_region][0]
+        except IndexError:
+            genome = dna_regions[dna_region]
+        genome_size = len(genome)
+        genome_rev = revCompIterative(genome)
+        with open(tool_pred, 'r') as MetaGeneAnnotator_input:
+            for line in MetaGeneAnnotator_input:
+                line = line.split()
+                if len(line) == 11 and dna_region in line[0]:
+                    if "gene_" in line[0]:
+                        start = int(line[1])
+                        stop = int(line[2])
+                        strand = line[3]
+                        if '-' in strand:  # Reverse Compliment starts and stops adjusted
+                            r_start = genome_size - stop
+                            r_stop = genome_size - start
+                            startCodon = genome_rev[r_start:r_start + 3]
+                            stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+                        elif '+' in strand:
+                            startCodon = genome[start - 1:start + 2]
+                            stopCodon = genome[stop - 3:stop]
+                        po = str(start) + ',' + str(stop)
+                        orf = [strand, startCodon, stopCodon, 'CDS', 'MetaGeneAnnotator']
+                        metaGeneAnnotator_ORFs.update({po: orf})
+
+    for group in metaGeneAnnotator_ORFs:
+        metaGeneAnnotator_ORFs[group] = sortORFs(metaGeneAnnotator_ORFs[group])
+    return metaGeneAnnotator_ORFs

ORForise/Tools/MetaGeneMark/MetaGeneMark.py

@@ -0,0 +1,55 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def MetaGeneMark(*args):
+    tool_pred = args[0]
+    dna_regions = args[1]
+    if not dna_regions: # This triggers if dna_regions is an empty dict (GFF_Intersect passed nothing)
+        dna_regions = collections.OrderedDict()
+        with open(tool_pred, 'r') as MetaGeneMark_input:
+            for line in MetaGeneMark_input:
+                line = line.split()
+                if 'GeneMark.hmm' in line[4] and "CDS" in line[5] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    metaGeneMarkORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        metaGeneMarkORFs[dna_region] = collections.OrderedDict()
+    for dna_region in dna_regions:
+        try:
+            genome = dna_regions[dna_region][0]
+        except IndexError:
+            genome = dna_regions[dna_region]
+        genome_size = len(genome)
+        genome_rev = revCompIterative(genome)
+        with open(tool_pred, 'r') as metaGeneMark_input:
+            for line in metaGeneMark_input:
+                line = line.split()
+                if len(line) == 19:
+                    if 'GeneMark.hmm' in line[4] and "CDS" in line[5] and dna_region in line[0]:
+                        start = int(line[6])
+                        stop = int(line[7])
+                        strand = line[9]
+                        if '-' in strand:  # Reverse Compliment starts and stops adjusted
+                            r_start = genome_size - stop
+                            r_stop = genome_size - start
+                            startCodon = genome_rev[r_start:r_start + 3]
+                            stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+                        elif '+' in strand:
+                            startCodon = genome[start - 1:start + 2]
+                            stopCodon = genome[stop - 3:stop]
+                        po = str(start) + ',' + str(stop)
+                        orf = [strand, startCodon, stopCodon, 'CDS', 'MetaGeneMark']
+                        metaGeneMarkORFs.update({po: orf})
+
+    for group in metaGeneMarkORFs:
+        metaGeneMarkORFs[group] = sortORFs(metaGeneMarkORFs[group])
+    return metaGeneMarkORFs

ORForise/Tools/Prodigal/Prodigal.py

@@ -0,0 +1,55 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def Prodigal(*args):
+    tool_pred = args[0]
+    dna_regions = args[1]
+    if not dna_regions: # This triggers if dna_regions is an empty dict (GFF_Intersect passed nothing)
+        dna_regions = collections.OrderedDict()
+        with open(tool_pred, 'r') as Prodigal_input:
+            for line in Prodigal_input:
+                line = line.split()
+                if "Prodigal" in line[1] and "CDS" in line[2] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    prodigal_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        prodigal_ORFs[dna_region] = collections.OrderedDict()
+    for dna_region in dna_regions:
+        try:
+            genome = dna_regions[dna_region][0]
+        except IndexError:
+            genome = dna_regions[dna_region]
+        genome_size = len(genome)
+        genome_rev = revCompIterative(genome)
+        with open(tool_pred, 'r') as prodigal_input:
+            for line in prodigal_input:
+                line = line.split()
+                if "Prodigal" in line[1] and dna_region in line[0] and "CDS" in line[2]:
+                    start = int(line[3])
+                    stop = int(line[4])
+                    strand = line[6]
+                    info = line[8]
+                    if '-' in strand:  # Reverse Compliment starts and stops adjusted
+                        r_start = genome_size - stop
+                        r_stop = genome_size - start
+                        startCodon = genome_rev[r_start:r_start + 3]
+                        stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+                    elif '+' in strand:
+                        startCodon = genome[start - 1:start + 2]
+                        stopCodon = genome[stop - 3:stop]
+                    po = str(start) + ',' + str(stop)
+                    orf = [strand, startCodon, stopCodon, 'CDS', 'Prodigal']
+                    prodigal_ORFs[dna_region].update({po: orf})
+
+    for group in prodigal_ORFs:
+        prodigal_ORFs[group] = sortORFs(prodigal_ORFs[group])
+    return prodigal_ORFs

ORForise/Tools/Prokka/Prokka.py

@@ -0,0 +1,57 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def Prokka(*args): # UNFINISHED
+    tool_pred = args[0]
+    dna_regions = args[1]
+    types = args[2]
+    if not dna_regions: # This triggers if dna_regions is an empty dict (GFF_Intersect passed nothing)
+        dna_regions = collections.OrderedDict()
+        with open(tool_pred, 'r') as PROKKA_input:
+            for line in PROKKA_input:
+                line = line.split()
+                if "Prodigal" in line[1] and "CDS" in line[2] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    prokkaORFs = collections.defaultdict(list)
+    for dna_region in dna_regions:
+        prokkaORFs[dna_region] = collections.OrderedDict()
+    for dna_region in dna_regions:
+        try:
+            genome = dna_regions[dna_region][0]
+        except IndexError:
+            genome = dna_regions[dna_region]
+        genome_size = len(genome)
+        genome_rev = revCompIterative(genome)
+        with open(tool_pred, 'r') as prodigal_input:
+            for line in prodigal_input:
+                if '#' not in line:
+                    line = line.split('\t')
+                    if "prokka" not in line[1] and line[8].startswith('ID=') and dna_region in line[0] and "CDS" in line[2]:
+                        start = int(line[3])
+                        stop = int(line[4])
+                        strand = line[6]
+                        info = line[8]
+                        if '-' in strand:  # Reverse Compliment starts and stops adjusted
+                            r_start = genome_size - stop
+                            r_stop = genome_size - start
+                            startCodon = genome_rev[r_start:r_start + 3]
+                            stopCodon = genome_rev[r_stop - 2:r_stop + 1]
+                        elif '+' in strand:
+                            startCodon = genome[start - 1:start + 2]
+                            stopCodon = genome[stop - 3:stop]
+                        po = str(start) + ',' + str(stop)
+                        orf = [strand, startCodon, stopCodon, line[2], 'Prokka']
+                        prokkaORFs.update({po: orf})
+
+    for group in prokkaORFs:
+        prokkaORFs[group] = sortORFs(prokkaORFs[group])
+    return prokkaORFs