ORForise 1.6.2__py3-none-any.whl

ORForise/StORForise.py

@@ -0,0 +1,115 @@
+from importlib import import_module
+import argparse
+import csv
+
+try:
+    from .Comparator import tool_comparison
+    from .utils import *
+except (ImportError, ModuleNotFoundError):
+    from Comparator import tool_comparison
+    from utils import *
+
+###################
+
+
+def comparator(tool, input_to_analyse, storfs_to_find_missing, genome_to_compare):
+    genome_Seq = ""
+    with open(genome_to_compare, 'r') as genome:
+        for line in genome:
+            line = line.replace("\n", "")
+            if ">" not in line:
+                genome_Seq += str(line)
+    ##############################################
+    genes = collections.OrderedDict()
+    count = 0
+    with open(input_to_analyse, 'r') as genome_gff:  # Get list of missed genes
+        for line in genome_gff:
+            if ">" in line:
+                line = line.strip()
+                start = int(line.split('_')[1])
+                stop = int(line.split('_')[2])
+                strand = line.split('_')[3]
+                gene_details = [start,stop,strand]
+                genes.update({count: gene_details})
+                count += 1
+    ##################################
+    tool_predictions = import_module('Tools.' + tool + '.' + tool)
+    tool_predictions = getattr(tool_predictions, tool)
+    orfs = tool_predictions(storfs_to_find_missing, genome_Seq)
+    all_Metrics, all_rep_Metrics, start_precision, stop_precision, other_starts, other_stops, perfect_Matches, missed_genes, unmatched_orfs, undetected_gene_metrics, unmatched_orf_metrics, orf_Coverage_Genome, matched_ORF_Coverage_Genome, gene_coverage_genome, multi_Matched_ORFs, partial_Hits = tool_comparison(
+        genes, orfs, genome_Seq,True)
+    outname = tool + '_' + genome_to_compare.split('/')[-1].split('.')[0]
+    metric_description = list(all_Metrics.keys())
+    metrics = list(all_Metrics.values())
+    rep_metric_description = list(all_rep_Metrics.keys())
+    rep_metrics = list(all_rep_Metrics.values())
+    with open("Tools/" + tool + '/' + outname + '.csv', 'w', newline='\n',
+              encoding='utf-8') as out_file:  # Clear write out of report
+        tool_out = csv.writer(out_file, quoting=csv.QUOTE_NONE, escapechar=" ")
+        tool_out.writerow(['Representative_Metrics:'])
+        tool_out.writerow(rep_metric_description)
+        tool_out.writerow(rep_metrics)
+        tool_out.writerow(['All_Metrics:'])
+        tool_out.writerow(metric_description)
+        tool_out.writerow(metrics)
+        tool_out.writerow(['CDS_Gene_Coverage_of_Genome:'])
+        tool_out.writerow([gene_coverage_genome])
+        tool_out.writerow(['Start_Position_Difference:'])
+        tool_out.writerow(start_precision)
+        tool_out.writerow(['Stop_Position_Difference:'])
+        tool_out.writerow(stop_precision)
+        tool_out.writerow(['Alternative_Starts_Predicted:'])
+        tool_out.writerow(other_starts)
+        tool_out.writerow(['Alternative_Stops_Predicted:'])
+        tool_out.writerow(other_stops)
+        tool_out.writerow(['Undetected_Gene_Metrics:'])
+        tool_out.writerow([
+                              'ATG_Start,GTG_Start,TTG_Start,ATT_Start,CTG_Start,Alternative_Start_Codon,TGA_Stop,TAA_Stop,TAG_Stop,Alternative_Stop_Codon,Median_Length,ORFs_on_Positive_Strand,ORFs_on_Negative_Strand'])
+        tool_out.writerow(undetected_gene_metrics)
+        tool_out.writerow(['Undetected_Genes:'])
+        for key, value in missed_genes.items():
+            key = key.split(',')
+            id = ('>' + genome_to_compare + '_' + key[0] + '_' + key[1] + '_' + key[2])
+            tool_out.writerow([id + '\n' + value])
+        tool_out.writerow(['\nORFs_Without_Corresponding_Gene_In_Ensembl_Metrics:'])
+        tool_out.writerow([
+            'ATG_Start,GTG_Start,TTG_Start,ATT_Start,CTG_Start,Alternative_Start_Codon,TGA_Stop,TAA_Stop,TAG_Stop,Alternative_Stop_Codon,Median_Length,ORFs_on_Positive_Strand,ORFs_on_Negative_Strand'])
+        tool_out.writerow(unmatched_orf_metrics)
+        tool_out.writerow(['ORF_Without_Corresponding_Gene_in_Ensembl:'])
+        for key, value in unmatched_orfs.items():
+            key = key.split(',')
+            id = ('>' + tool + '_' + key[0] + '_' + key[1] + '_' + key[2])
+            tool_out.writerow([id + '\n' + value])
+        tool_out.writerow(['\nORFs_Which_Detected_more_than_one_Gene:'])
+
+        try:
+            for key, value in multi_Matched_ORFs.items():
+                key = key.split(',')
+                value = value[1].split(',')
+                multi = ('ORF:' + key[0] + '-' + key[1] + '_Gene:' + value[0] + '-' + value[1])
+                tool_out.writerow([multi])
+        except IndexError:
+            pass
+
+        tool_out.writerow(['\n\nPartial_Gene_Hits:'])
+        for key, seqs in partial_Hits.items():
+            key = key.split(';')
+            gene_Seq = seqs[0]
+            orf_Seq = seqs[1]
+            partial = (key[0] + '\n' + gene_Seq + '\n' + key[1] + '\n' + orf_Seq + '\n')
+            tool_out.writerow([partial])
+
+
+def main():
+    print(WELCOME)
+    parser = argparse.ArgumentParser(description='ORForise ' + ORForise_Version + ': StORForise Run Parameters.')
+    parser.add_argument('-t', '--tool', default='GFF', help='Which tool/format would you analyse with StORF-R?')
+    parser.add_argument('-i', '--input_to_analyse', default='', help='Location of file containing missed genes')
+    parser.add_argument('-stf', '--storfs_to_find_missing', default='', help='STORFs to find missing.')
+    parser.add_argument('-g', '--genome_to_compare', default='', help='Which genome to analyse?')
+    args = parser.parse_args()
+
+    comparator(**vars(args))
+
+if __name__ == "__main__":
+    main()

ORForise/Tools/Augustus/Augustus.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 Augustus(*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 Augustus_input:
+            for line in Augustus_input:
+                line = line.split()
+                if len(line) == 10 and "CDS" in line[2] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    augustus_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        augustus_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 Augustus_input:
+            for line in Augustus_input:
+                line = line.split()
+                if len(line) == 12 and dna_region in line[0] and "CDS" in line[2]:
+                    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', 'Augustus']
+                    augustus_ORFs.update({po: orf})
+
+        for group in augustus_ORFs:
+            augustus_ORFs[group] = sortORFs(augustus_ORFs[group])
+        return augustus_ORFs

ORForise/Tools/Balrog/Balrog.py

@@ -0,0 +1,56 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def Balrog(*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 Balrog_input:
+            for line in Balrog_input:
+                line = line.split()
+                if "CDS" in line[2] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    Balrog_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        Balrog_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 Balrog_input:
+            for line in Balrog_input:
+                if '#' not in line:
+                    line = line.split('\t')
+                    if "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', 'Balrog']
+                        Balrog_ORFs.update({po: orf})
+
+    for group in Balrog_ORFs:
+        Balrog_ORFs[group] = sortORFs(Balrog_ORFs[group])
+    return Balrog_ORFs

ORForise/Tools/EasyGene/EasyGene.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 EasyGene(*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 EasyGene_input:
+            for line in EasyGene_input:
+                line = line.split()
+                if len(line) == 10 and line[0] and "CDS" in line[2] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    easyGene_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        easyGene_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 EasyGene_input:
+            for line in EasyGene_input:
+                line = line.split()
+                if len(line) == 10 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', 'EasyGene']
+                    easyGene_ORFs[dna_region].update({po: orf})
+
+    for group in easyGene_ORFs:
+        easyGene_ORFs[group] = sortORFs(easyGene_ORFs[group])
+    return easyGene_ORFs

ORForise/Tools/FGENESB/FGENESB.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 FGENESB(*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 FGENESB_input:
+            for line in FGENESB_input:
+                line = line.split()
+                if len(line) == 10 and ">GENE" in line[0] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    FGENESB_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        FGENESB_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 FGENESB_input:
+            for line in FGENESB_input:
+                if '>GENE' in line:
+                    line = line.split()
+                    if '2208' in line:
+                        print("ss")
+                    if len(line) == 10 and dna_region in line[0] and ">GENE" in line[0]:
+                        start = int(line[2])
+                        stop = int(line[4])
+                        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', 'FGENESB']
+                        FGENESB_ORFs.update({po: orf})
+
+    for group in FGENESB_ORFs:
+        FGENESB_ORFs[group] = sortORFs(FGENESB_ORFs[group])
+    return FGENESB_ORFs

ORForise/Tools/FragGeneScan/FragGeneScan.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 FragGeneScan(*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 fragGeneScan_input:
+            for line in fragGeneScan_input:
+                line = line.split()
+                if len(line) == 10 and "FGS" 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
+
+    fragGeneScan_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        fragGeneScan_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 fragGeneScan_input:
+            for line in fragGeneScan_input:
+                line = line.split()
+                if len(line) == 10 and "FGS" in line[1] 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', 'FragGeneScan']
+                    fragGeneScan_ORFs.update({po: orf})
+
+    for group in fragGeneScan_ORFs:
+        fragGeneScan_ORFs[group] = sortORFs(fragGeneScan_ORFs[group])
+    return fragGeneScan_ORFs

ORForise/Tools/GFF/GFF.py

@@ -0,0 +1,77 @@
+import collections
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def GFF(*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 GFF_input:
+            for line in GFF_input:
+                line = line.split()
+                if 'CDS' in line[2] and len(line) == 9 and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    GFF_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        GFF_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 gff_input:
+            for line in gff_input:
+                if '#' not in line:
+                    line = line.split('\t')
+                    #gene_types = types.split(',') - Temporary fix
+                    #if any(gene_type == line[2] for gene_type in gene_types) and len(line) == 9:  # line[2] for normalrun
+                    if 'CDS' in line[2] and len(line) == 9 and dna_region in line[0]:
+                        start = int(line[3])
+                        stop = int(line[4])
+                        strand = line[6]
+                        info = line[8]
+                        if stop >= genome_size:
+                            extra_stop = stop - genome_size
+                            corrected_stop = genome_size
+                            if '-' in strand:  # Reverse Compliment starts and stops adjusted
+                                r_start = genome_size - corrected_stop
+                                r_stop = genome_size - start
+                                seq = genome_rev[r_start:r_stop + 1]
+                                extra_seq = genome_rev[-extra_stop - 1:]
+                                seq = extra_seq+seq
+                                startCodon = seq[:3]
+                                stopCodon = seq[-3:]
+                            elif '+' in strand:
+                                seq = genome[start -1 :corrected_stop]
+                                extra_seq = genome[:extra_stop +1]
+                                seq = seq+extra_seq
+                                startCodon = seq[:3]
+                                stopCodon = seq[-3:]
+                        else:
+                            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], 'GFF-Standard'] # This needs to detect the type
+                        GFF_ORFs.update({po: orf})
+                    # elif "CDS" in line[2]:
+                    #     sys.exit("SAS")
+
+    for group in GFF_ORFs:
+        GFF_ORFs[group] = sortORFs(GFF_ORFs[group])
+    return GFF_ORFs

ORForise/Tools/GLIMMER3/GLIMMER3.py

@@ -0,0 +1,59 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def GLIMMER_3(*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 GLIMKMER_input:
+            for line in GLIMMER_input:
+                line = line.split()
+                if len(line) == 5 and "orf" in line[0] and line[0] not in dna_regions:
+                    dna_regions[line[0]] = []  # Placeholder for genome sequence
+        return dna_regions
+
+    GLIMMER_ORFs = collections.OrderedDict()
+    for dna_region in dna_regions:
+        GLIMMER_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 glimmer_input:  # GLIMMER3 reverses the start and stop positions for ORFS on the negative strand
+            for line in glimmer_input:
+                if '>' not in line:  # This will not work with multiple contigs
+                    line = line.split()
+                    if len(line) == 5 and "orf" in line[0] and dna_region in line[0]:
+                        if '-' in line[3]:  # Reverse Compliment starts and stops adjusted -  Switched to match Sense Strand
+                            start = int(line[2])
+                            stop = int(line[1])
+                            strand = '-'
+                            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 line[3]:
+                            start = int(line[1])
+                            stop = int(line[2])
+                            strand = '+'
+                            startCodon = genome[start - 1:start + 3]
+                            stopCodon = genome[stop - 3:stop]
+                        po = str(start) + ',' + str(stop)
+                        orf = [strand, startCodon, stopCodon, 'CDS', 'GLIMMER3']
+                        GLIMMER_ORFs.update({po: orf})
+
+    for group in GLIMMER_ORFs:
+        GLIMMER_ORFs[group] = sortORFs(GLIMMER_ORFs[group])
+    return GLIMMER_ORFs