ORForise 1.6.2__py3-none-any.whl

ORForise/ORForise_Analysis/gene_Lenghts.py

@@ -0,0 +1,28 @@
+import argparse
+import numpy as np
+
+parser = argparse.ArgumentParser()
+parser.add_argument('-g', '--genome_to_compare', default='', help='Which genome to analyse?')
+args = parser.parse_args()
+
+
+def genome_Lengths(genome_to_compare):
+    lengths = []
+    with open('../Genomes/' + genome_to_compare + '.gff', 'r') as genome_gff:
+        for line in genome_gff:
+            line = line.split('\t')
+            try:
+                if "CDS" in line[2] and len(line) == 9:
+                    start = int(line[3])
+                    stop = int(line[4])
+                    length = stop - start
+                    lengths.append(length)
+            except IndexError:
+                # print(line)
+                continue
+    print("Number of Genes: " + str(len(lengths)) +
+          '\tMedian Length of Genes: ' + str(np.median(lengths)) + '\nGenes Lengths:\n' + str(lengths))
+
+
+if __name__ == "__main__":
+    genome_Lengths(**vars(args))

ORForise/ORForise_Analysis/genome_Metrics.py

@@ -0,0 +1,258 @@
+import argparse
+import numpy as np
+import os
+
+try:
+    from ORForise.src.ORForise.utils import *  # local file
+except ImportError:
+    from ORForise.utils import *
+
+
+
+
+def start_Codon_Count(start_Codons):
+    atg, gtg, ttg, att, ctg, other = 0, 0, 0, 0, 0, 0
+    other_Starts = []
+    for start in start_Codons:
+        if start == 'ATG':
+            atg += 1
+        elif start == 'GTG':
+            gtg += 1
+        elif start == 'TTG':
+            ttg += 1
+        elif start == 'ATT':
+            att += 1
+        elif start == 'CTG':
+            ctg += 1
+        else:
+            other += 1
+            other_Starts.append(start)
+    atg_P = format(100 * atg / len(start_Codons), '.2f')
+    gtg_P = format(100 * gtg / len(start_Codons), '.2f')
+    ttg_P = format(100 * ttg / len(start_Codons), '.2f')
+    att_P = format(100 * att / len(start_Codons), '.2f')
+    ctg_P = format(100 * ctg / len(start_Codons), '.2f')
+    other_Start_P = format(100 * other / len(start_Codons), '.2f')
+    return atg_P, gtg_P, ttg_P, att_P, ctg_P, other_Start_P, other_Starts
+
+
+def stop_Codon_Count(stop_Codons):
+    tag, taa, tga, other = 0, 0, 0, 0
+    other_Stops = []
+    for stop in stop_Codons:
+        if stop == 'TAG':
+            tag += 1
+        elif stop == 'TAA':
+            taa += 1
+        elif stop == 'TGA':
+            tga += 1
+        else:
+            other += 1
+            other_Stops.append(stop)
+    tag_p = format(100 * tag / len(stop_Codons), '.2f')
+    taa_p = format(100 * taa / len(stop_Codons), '.2f')
+    tga_p = format(100 * tga / len(stop_Codons), '.2f')
+    other_Stop_P = format(100 * other / len(stop_Codons), '.2f')
+    return tag_p, taa_p, tga_p, other_Stop_P, other_Stops
+
+
+def gc_count(dna):
+    c = 0
+    a = 0
+    g = 0
+    t = 0
+    n = 0
+    for i in dna:
+        if "C" in i:
+            c += 1
+        elif "G" in i:
+            g += 1
+        elif "A" in i:
+            a += 1
+        elif "T" in i:
+            t += 1
+        elif "N" in i:
+            n += 1
+    gc_content = (g + c) * 100 / (a + t + g + c + n)
+    n_per = n * 100 / (a + t + g + c + n)
+    return n_per, gc_content
+
+
+def revCompIterative(watson):
+    complements = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C', 'N': 'N'}
+    watson = watson.upper()
+    watsonrev = watson[::-1]
+    crick = ""
+
+    for nt in watsonrev:
+        crick += complements[nt]
+    return crick
+
+
+def genome_Metrics(fasta_in, gff_in, output_file):
+
+    base_name = os.path.basename(fasta_in)  # Gets file name with extension
+    genome_name = os.path.splitext(base_name)[0]  # Removes extension
+
+    genome_Seq = ""
+    with open(fasta_in , 'r') as genome:
+        for line in genome:
+            line = line.replace("\n", "")
+            if not line.startswith('>'):
+                genome_Seq += str(line)
+
+    genome_N_Per, genome_GC = gc_count(genome_Seq)
+
+    genome_Rev = revCompIterative(genome_Seq)
+    genome_Size = len(genome_Seq)
+    coding_Regions = np.zeros((genome_Size), dtype=int)
+    non_Coding_Regions = np.zeros((genome_Size), dtype=int)
+    all_gene_Regions = np.zeros((genome_Size), dtype=int)
+    protein_coding_genes = collections.OrderedDict()
+    non_protein_coding_genes = collections.OrderedDict()
+    strands = collections.defaultdict(int)
+    lengths_PCG, gene_Pos_Olap, gene_Neg_Olap, short_PCGs, pcg_GC = [], [], [], [], []
+    prev_Gene_Stop, count, nc_Count, pos_Strand, neg_Strand = 0, 0, 0, 0, 0
+    prev_Gene_Overlapped = False
+    with open(gff_in, 'r') as genome_gff:
+        for line in genome_gff:
+            line = line.split('\t')
+            try:
+                if "CDS" in line[2] and len(line) == 9:
+                    start = int(line[3])
+                    stop = int(line[4])
+                    length = stop - start
+                    all_gene_Regions[start - 1:stop] = [1]
+                    strand = line[6]
+                    strands[strand] += 1
+                    lengths_PCG.append(length)
+                    coding_Regions[start - 1:stop] = [1]
+                    gene = str(start) + ',' + str(stop) + ',' + strand
+                    protein_coding_genes.update({count: gene})
+                    if '+' in strand:
+                        seq = genome_Seq[start - 1:stop]
+                        pos_Strand += 1
+                    elif '-' in strand:
+                        r_Start = genome_Size - stop
+                        r_Stop = genome_Size - start
+                        seq = genome_Rev[r_Start:r_Stop + 1]
+                        neg_Strand += 1
+                    if length < SHORT_ORF_LENGTH:
+                        short_PCGs.append(gene)
+                    n_per, gc = gc_count(seq)
+                    pcg_GC.append(gc)
+                    ### Calculate overlapping ORFs -
+                    if prev_Gene_Stop > start:
+                        if '+' in strand:
+                            gene_Pos_Olap.append(prev_Gene_Stop - start)
+                        elif '-' in strand:
+                            gene_Neg_Olap.append(prev_Gene_Stop - start)
+                        prev_Gene_Overlapped = True
+                    elif prev_Gene_Stop < start:
+                        if prev_Gene_Overlapped == True:
+                            if '+' in strand:
+                                gene_Pos_Olap.append(0)
+                            elif '-' in strand:
+                                gene_Neg_Olap.append(0)
+                        prev_Gene_Overlapped = False
+                    prev_Gene_Stop = stop
+                    count += 1
+                elif "ID=gene" in line[8]:
+                    gene_Info = line[8]
+                    if "biotype=protein_coding" not in gene_Info:
+                        start = int(line[3])
+                        stop = int(line[4])
+                        strand = line[6]
+                        gene = str(start) + ',' + str(stop) + ',' + strand
+                        all_gene_Regions[start - 1:stop] = [1]
+                        non_Coding_Regions[start - 1:stop] = [1]
+                        non_protein_coding_genes.update({nc_Count: gene})
+                        nc_Count += 1
+
+            except IndexError:
+                continue
+
+        if prev_Gene_Overlapped == True:  # If last has a prev overlap, count it
+            if '+' in strand:
+                gene_Pos_Olap.append(0)
+            elif '-' in strand:
+                gene_Neg_Olap.append(0)
+
+    median_PCG = np.median(lengths_PCG)
+    gene_Overlaps = gene_Neg_Olap + gene_Pos_Olap
+    median_PCG_Olap = np.median(gene_Overlaps)
+    longest_Olap = max(gene_Overlaps)
+    coding_Percentage = 100 * float(np.count_nonzero(coding_Regions)) / float(genome_Size)
+    non_coding_Percentage = 100 * float(np.count_nonzero(non_Coding_Regions)) / float(genome_Size)
+    all_gene_Percentage = 100 * float(np.count_nonzero(all_gene_Regions)) / float(genome_Size)
+    start_Codons, stop_Codons = [], []
+    for gene in protein_coding_genes.values():
+        start = int(gene.split(',')[0])
+        stop = int(gene.split(',')[1])
+        strand = gene.split(',')[2]
+
+        if '-' in strand:
+            r_start = genome_Size - stop
+            r_stop = genome_Size - start
+
+            start_Codons.append(genome_Rev[r_start:r_start + 3])
+            stop_Codons.append(genome_Rev[r_stop - 2:r_stop + 1])
+
+        elif '+' in strand:
+            start_Codons.append(genome_Seq[start - 1:start - 1 + 3])
+            stop_Codons.append(genome_Seq[stop - 3:stop - 1 + 1])
+
+    atg_P, gtg_P, ttg_P, att_P, ctg_P, other_Start_P, other_Starts = start_Codon_Count(start_Codons)
+    tag_P, taa_P, tga_P, other_Stop_P, other_Stops = stop_Codon_Count(stop_Codons)
+
+    output = ("Number of Protein Coding Genes in " + genome_name + " : " + str(
+        len(lengths_PCG)) + " ,Median Length of PCGs: " + str(median_PCG) + ", Min Length of PCGs: " + str(
+        min(lengths_PCG)) + ", Max Length of PCGs: " + str(max(lengths_PCG)) +
+              ", Number of PCGs on Pos Strand: " + str(strands['+']) + ", Number of PCGs on Neg Strand: " + str(
+                strands['-']) + "\nGenome-Wide GC Content: " + format(np.median(genome_GC),
+                                                                      '.2f') + "Median GC of PCGs: " + format(
+                np.median(pcg_GC), '.2f') + ", Number of Overlapping PCGs: " + str(len(gene_Overlaps)) +
+              ", Longest PCG Overlap: " + str(longest_Olap) + ", Median PCG Overlap: " + str(
+                median_PCG_Olap) + ", Number of PCGs less than 100 amino acids: " + str(len(short_PCGs)) +
+
+              "\nPercentage of Genome which is Protein Coding: " + format(coding_Percentage,
+                                                                          '.2f') + ", Number of Non-PCGs: " + str(
+                len(non_protein_coding_genes)) + ", Percentage of Genome Non-PCG: " + format(non_coding_Percentage,
+                                                                                             '.2f') +
+              ", Percentage of All Genes in Genome: " + format(all_gene_Percentage, '.2f') +
+
+              "\nPercentage of Genes starting with ATG: " + atg_P +
+              "\nPercentage of Genes starting with GTG: " + gtg_P +
+              "\nPercentage of Genes starting with TTG: " + ttg_P +
+              "\nPercentage of Genes starting with ATT: " + att_P +
+              "\nPercentage of Genes starting with CTG: " + ctg_P +
+              "\nPercentage of Genes starting with Alternative Start Codon: " + other_Start_P +
+
+              "\nPercentage of Genes ending with TAG: " + tag_P +
+              "\nPercentage of Genes ending with TAA: " + taa_P +
+              "\nPercentage of Genes ending with TGA: " + tga_P +
+              "\nPercentage of Genes ending with Alternative Stop Codon: " + other_Stop_P)
+
+    with open(output_file, 'w') as out_file:
+        out_file.write('Genome Metrics:\n')
+        out_file.write(output + '\n')
+
+    #print(output)
+
+
+
+
+def main():
+    parser = argparse.ArgumentParser(description="...")
+    parser.add_argument("-f", dest='fasta_in', required=True, help="Input FASTA file")
+    parser.add_argument("-g", dest='gff_in', required=True, help="Corresponding GFF file to FASTA")
+    parser.add_argument("-o", dest='output_file', required=True, help="Output metrics file")
+
+    options = parser.parse_args()
+
+    genome_Metrics(options.fasta_in, options.gff_in, options.output_file)
+
+
+
+if __name__ == "__main__":
+   main()

ORForise/ORForise_Analysis/hypothetical_gene_predictions.py

@@ -0,0 +1,88 @@
+import argparse
+import collections
+
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument('-ref', '--reference_annotation', required=True,
+                    help='Which reference annotation file to use as reference?')
+parser.add_argument('-tp', '--tool_prediction', required=True, help='Tool genome prediction file')
+args = parser.parse_args()
+
+
+def main(reference_annotation,tool_prediction):
+    ref_genes = collections.OrderedDict()  # Order is important
+    num_hypo = 0
+    with open(reference_annotation, 'r') as genome_gff:
+        for line in genome_gff:
+            line = line.split('\t')
+            try:
+                if "gene" in line[2] and len(line) == 9: # Have to use gene and not CDS here because the CDS tag does not contain the classification
+                    start = line[3]
+                    stop = line[4]
+                    gene = start+'_'+stop
+                    if "hypothetical" in line[8]:
+                        ref_genes.update({gene:"hypothetical"})
+                        num_hypo +=1
+                    else:
+                        ref_genes.update({gene: "N/A"})
+            except IndexError:
+                continue
+    print("Number of hypothetic genes: "+str(num_hypo))
+    ###############################
+    perfect_match_hypo, partial_match_hypo, missed_hypo = 0,0,0
+    perfect_match = False
+    partial_match = False
+    missed = False
+    posss = []
+    with open(tool_prediction, 'r') as tool_in:
+        for line in tool_in:
+            if line.startswith("Perfect_Match_Genes:"):
+                perfect_match = True
+            elif line.startswith("Partial_Match_Genes:"):
+                perfect_match = False
+                partial_match = True
+            elif line.startswith("Missed_Genes:"):
+                perfect_match = False
+                partial_match = False
+                missed = True
+            elif line.startswith("ORF_Without_Corresponding_Gene_in_Ensembl"):
+                break
+            #################
+            if perfect_match == True:
+                if line.startswith('>'):
+                    pos = line.split('_')[1] +'_'+ line.split('_')[2]
+                    try:
+                        if "hypothetical" in ref_genes[pos]:
+                            perfect_match_hypo +=1
+                            print(pos)
+                            if pos in posss:
+                                print("WE")
+                            posss.append(pos)
+                    except KeyError:
+                        continue
+            elif partial_match == True:
+                if line.startswith('Gene:'): # Different tags
+                    pos = line.split('_')[0].split(':')[1] +'_'+ line.split('_')[1] # should change Orforise output
+                    try:
+                        if "hypothetical" in ref_genes[pos]:
+                            partial_match_hypo +=1
+                            print(pos)
+                    except KeyError:
+                        continue
+            elif missed == True:
+                if line.startswith('>'):
+                    pos = line.split('_')[1] +'_'+ line.split('_')[2]
+                    try:
+                        if "hypothetical" in ref_genes[pos]:
+                            missed_hypo +=1
+                            print(pos)
+                    except KeyError:
+                        continue
+
+    print("finished")
+
+if __name__ == "__main__":
+    main(**vars(args))
+
+    print("Complete")

ORForise/ORForise_Analysis/missed_Gene_Metrics.py

@@ -0,0 +1,277 @@
+import argparse
+import collections
+import numpy as np
+
+from ORForise.src.ORForise.utils import *
+
+parser = argparse.ArgumentParser()
+parser.add_argument('-t', '--tool', required=True, help='Which tool to compare?')
+parser.add_argument('-p', '--parameters', required=False, help='Optional parameters for prediction tool.')
+parser.add_argument('-g', '--genome', required=True, help='Which genome to analyse?')
+
+args = parser.parse_args()
+
+
+def gc_count(dna):
+    c = 0
+    a = 0
+    g = 0
+    t = 0
+    n = 0
+    for i in dna:
+        if "C" in i:
+            c += 1
+        elif "G" in i:
+            g += 1
+        elif "A" in i:
+            a += 1
+        elif "T" in i:
+            t += 1
+        elif "N" in i:
+            n += 1
+    gc_content = format((g + c) * 100 / (a + t + g + c + n), '.2f')
+    n_per = n * 100 / (a + t + g + c + n)
+    return n_per, gc_content
+
+
+def revCompIterative(watson):
+    complements = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C', 'N': 'N'}
+    watson = watson.upper()
+    watsonrev = watson[::-1]
+    crick = ""
+    for nt in watsonrev:
+        crick += complements[nt]
+    return crick
+
+
+def start_Codon_Count(orfs):
+    atg, gtg, ttg, att, ctg, other = 0, 0, 0, 0, 0, 0
+    other_Starts = []
+    for orf in orfs.values():
+        codon = orf[-2]
+        if codon == 'ATG':
+            atg += 1
+        elif codon == 'GTG':
+            gtg += 1
+        elif codon == 'TTG':
+            ttg += 1
+        elif codon == 'ATT':
+            att += 1
+        elif codon == 'CTG':
+            ctg += 1
+        else:
+            other += 1
+            other_Starts.append(codon)
+    atg_P = format(100 * atg / len(orfs), '.2f')
+    gtg_P = format(100 * gtg / len(orfs), '.2f')
+    ttg_P = format(100 * ttg / len(orfs), '.2f')
+    att_P = format(100 * att / len(orfs), '.2f')
+    ctg_P = format(100 * ctg / len(orfs), '.2f')
+    other_Start_P = format(100 * other / len(orfs), '.2f')
+    return atg_P, gtg_P, ttg_P, att_P, ctg_P, other_Start_P, other_Starts
+
+
+def stop_Codon_Count(orfs):
+    tag, taa, tga, other = 0, 0, 0, 0
+    other_Stops = []
+    for orf in orfs.values():
+        codon = orf[-1]
+        if codon == 'TAG':
+            tag += 1
+        elif codon == 'TAA':
+            taa += 1
+        elif codon == 'TGA':
+            tga += 1
+        else:
+            other += 1
+            other_Stops.append(codon)
+    tag_p = format(100 * tag / len(orfs), '.2f')
+    taa_p = format(100 * taa / len(orfs), '.2f')
+    tga_p = format(100 * tga / len(orfs), '.2f')
+    other_Stop_P = format(100 * other / len(orfs), '.2f')
+    return tag_p, taa_p, tga_p, other_Stop_P, other_Stops
+
+
+def missed_gene_read(results_file, missed_genes):
+    # Missed Genes Read-In
+    read = False
+    for line in results_file:
+        if line.startswith('ORFs_Without_Corresponding_Gene_In_Ensembl_Metrics:'):
+            break
+        line = line.strip()
+        if read == True:
+            if line.startswith('>'):
+                entry = line.split('_')
+                entry = entry[1] + '_' + entry[2]
+            elif len(line.strip()) > 0:
+                startCodon = line[0:3]
+                stopCodon = line[-3:]
+                length = len(line)
+                missed_genes.update({entry: [line, length, startCodon, stopCodon]})
+        if line.startswith('Undetected_Genes:'):
+            read = True
+
+    return missed_genes
+
+
+def detail_transfer(genes, missed_genes):
+    for missed, m_details in missed_genes.items():
+        try:
+            details = genes[missed]
+            gc = details[2]
+            up_Overlap = details[3]
+            down_Overlap = details[4]
+            m_details.insert(2, gc)
+            m_details.insert(3, up_Overlap)
+            m_details.insert(4, down_Overlap)
+        except KeyError:
+            pass
+    return missed_genes
+
+
+def result_compare(genome, results_file):
+    genome_Seq = ""
+    with open('../Genomes/' + genome + '.fa', 'r') as genome_file:
+        for line in genome_file:
+            line = line.replace("\n", "")
+            if ">" not in line:
+                genome_Seq += str(line)
+
+    missed_genes = collections.OrderedDict()
+    missed_genes = missed_gene_read(results_file, missed_genes)
+    list_MG = list(missed_genes.keys())
+    # Analysis
+    genome_Rev = revCompIterative(genome_Seq)
+    genome_Size = len(genome_Seq)
+    genes = collections.OrderedDict()
+    count = 0
+    prev_Stop = 0
+    ### Record Missed and Detected Gene metrics
+    genes_strand = collections.defaultdict(int)
+    genes_Missed_strand = collections.defaultdict(int)
+    short_PCGs, short_Missed_PCGs, pcg_GC, pcg_Missed_GC, lengths_PCG, lengths_Missed_PCG, genes_Overlap, genes_Missed_Overlap = [], [], [], [], [], [], [], []
+    with open('../Genomes/' + genome + '.gff', 'r') as genome_gff:
+        for line in genome_gff:
+            line = line.split('\t')
+            try:
+                if "CDS" in line[2] and len(line) == 9:
+                    start = int(line[3])
+                    stop = int(line[4])
+                    strand = line[6]
+                    gene = str(start) + ',' + str(stop) + ',' + strand
+                    if strand == '-':
+                        r_Start = genome_Size - stop
+                        r_Stop = genome_Size - start
+                        seq = (genome_Rev[r_Start:r_Stop + 1])
+                    elif strand == '+':
+                        seq = (genome_Seq[start - 1:stop])
+                    startCodon = seq[0:3]
+                    stopCodon = seq[-3:]
+                    length = stop - start
+                    n_per, gc = gc_count(seq)
+                    pos = str(start) + '_' + str(stop)
+                    if pos in list_MG:
+                        genes_Missed_strand[strand] += 1
+                        pcg_Missed_GC.append(float(gc))
+                        lengths_Missed_PCG.append(length)
+                        if length < SHORT_ORF_LENGTH:
+                            short_Missed_PCGs.append(gene)
+                        if prev_Stop > start:
+                            overlap = prev_Stop - start
+                            genes_Missed_Overlap.append(overlap)
+                        else:
+                            overlap = 0
+                    elif pos not in list_MG:
+                        genes_strand[strand] += 1
+                        pcg_GC.append(float(gc))
+                        lengths_PCG.append(length)
+                        if length < SHORT_ORF_LENGTH:
+                            short_PCGs.append(gene)
+                        if prev_Stop > start:
+                            overlap = prev_Stop - start
+                            genes_Overlap.append(overlap)
+                        else:
+                            overlap = 0
+
+                    count += 1
+                    prev_Stop = stop
+                    pos = str(start) + '_' + str(stop)
+                    if genes:
+                        prev_details = genes[prev_pos]
+                        prev_details.insert(4, overlap)
+                        genes.update({prev_pos: prev_details})
+
+                    genes.update({pos: [strand, length, gc, overlap, seq, startCodon, stopCodon]})
+                    prev_pos = pos
+
+            except IndexError:
+                continue
+
+    missed_genes = detail_transfer(genes, missed_genes)
+
+    missed_lengths = []
+    gene_lengths = []
+    for key in list_MG:
+        ### printed out to confirm figure lengths
+        start = key.split('_')[0]
+        stop = key.split('_')[1]
+        m_length = int(stop) - int(start)
+        missed_lengths.append(m_length)
+        if key in genes:
+            del genes[key]
+
+    ## Printed out for Figure of gene lengths
+    for key in genes.keys():
+        start = key.split('_')[0]
+        stop = key.split('_')[1]
+        g_length = int(stop) - int(start)
+        gene_lengths.append(g_length)
+
+    print("Number of Genes Missed:" + str(len(missed_lengths)) + '\nLengths of Genes Missed:\n' + str(missed_lengths))
+
+    median_PCG = np.median(lengths_PCG)
+    median_PCG_Olap = np.median(genes_Overlap)
+    longest_Olap = max(genes_Overlap)
+    num_overlaps = len(genes_Overlap)
+    gc_median = format(np.median(pcg_GC), '.2f')
+    num_Short_PCGs = len(short_PCGs)
+
+    atg_P, gtg_P, ttg_P, att_P, ctg_P, other_Starts_P, other_Starts = start_Codon_Count(genes)
+    tag_P, taa_P, tga_P, other_Stops_P, other_Stops = stop_Codon_Count(genes)
+    m_atg_P, m_gtg_P, m_ttg_P, m_att_P, m_ctg_P, m_other_Starts_P, m_other_Starts = start_Codon_Count(missed_genes)
+    m_tag_P, m_taa_P, m_tga_P, m_other_Stops_P, m_other_Stops = stop_Codon_Count(missed_genes)
+
+    output = ("Number of Missed Protein Coding Genes in " + str(genome) + " : " + str(
+        len(lengths_PCG)) + ", Median Length of PCGs: " +
+              str(median_PCG) + ", Min Length of PCGs: " + str(min(lengths_PCG)) + ", Max Length of PCGs: " + str(
+                max(lengths_PCG)) +
+              ", Number of PCGs on Pos Strand: " + str(
+                genes_Missed_strand['+']) + ", Number of PCGs on Neg Strand: " + str(genes_Missed_strand['-']) +
+              ", Median GC of PCGs: " + str(gc_median) + ", Number of Overlapping PCGs: " + str(num_overlaps) +
+              ", Longest PCG Overlap: " + str(longest_Olap) + ", Median PCG Overlap: " + str(median_PCG_Olap) +
+              ", Number of PCGs less than 100nt: " + str(num_Short_PCGs) +
+
+              '\nPercentage of Genes starting with ATG - Annotation/Missed: ' + atg_P + ' ' + m_atg_P +
+              '\nPercentage of Genes starting with GTG - Annotation/Missed: ' + gtg_P + ' ' + m_gtg_P +
+              '\nPercentage of Genes starting with TTG - Annotation/Missed: ' + ttg_P + ' ' + m_ttg_P +
+              '\nPercentage of Genes starting with ATT - Annotation/Missed: ' + att_P + ' ' + m_att_P +
+              '\nPercentage of Genes starting with CTG - Annotation/Missed: ' + ctg_P + ' ' + m_ctg_P +
+              '\nPercentage of Genes starting with Alternative Start Codon - Annotation/Missed: ' + other_Starts_P + ' ' + m_other_Stops_P +
+              '\nPercentage of Genes ending with TAG - Annotation/Missed: ' + tag_P + ' ' + m_tag_P +
+              '\nPercentage of Genes ending with TAA - Annotation/Missed: ' + taa_P + ' ' + m_taa_P +
+              '\nPercentage of Genes ending with TGA - Annotation/Missed: ' + tga_P + ' ' + m_tga_P +
+              '\nPercentage of Genes ending with Alternative Stop Codon - Annotation/Missed: ' + other_Stops_P + ' ' + m_other_Stops_P)
+
+    print(output)
+
+
+if __name__ == "__main__":
+    options = parser.parse_args()
+    parameters = options.parameters
+    tool = options.tool
+    genome = options.genome
+    if parameters:
+        results_file = open('../Tools/' + tool + '/' + tool + '_' + genome + '_' + parameters + '.csv')
+    else:
+        results_file = open('../Tools/' + tool + '/' + tool + '_' + genome + '.csv')
+    result_compare(genome, results_file)