ORForise 1.6.2__py3-none-any.whl

ORForise/ORForise_Analysis/parital_Match_Analysis.py

@@ -0,0 +1,230 @@
+import argparse
+import collections
+import numpy as np
+import sys
+
+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')
+    return 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(starts, lengths):
+    try:
+        atg_P = format(100 * starts['ATG'] / len(lengths), '.2f')
+        gtg_P = format(100 * starts['GTG'] / len(lengths), '.2f')
+        ttg_P = format(100 * starts['TTG'] / len(lengths), '.2f')
+        att_P = format(100 * starts['ATT'] / len(lengths), '.2f')
+        ctg_P = format(100 * starts['CTG'] / len(lengths), '.2f')
+    except ZeroDivisionError:
+        atg_P, gtg_P, ttg_P, att_P, ctg_P = 0, 0, 0, 0, 0
+    return atg_P, gtg_P, ttg_P, att_P, ctg_P  # ,other_Start_P,other_Starts
+
+
+def stop_Codon_Count(stops, lengths):
+    try:
+        tag_P = format(100 * stops['TAG'] / len(lengths), '.2f')
+        taa_P = format(100 * stops['TAA'] / len(lengths), '.2f')
+        tga_P = format(100 * stops['TGA'] / len(lengths), '.2f')
+    # return atg_P, gtg_P, ttg_P, att_P, ctg_P  # ,other_Start_P,other_Starts
+    except ZeroDivisionError:
+        tag_P, taa_P, tga_P = 0, 0, 0
+    return tag_P, taa_P, tga_P  # ,other_Stop_P,other_Stops
+
+
+def partial_gene_read(results_file, partial_genes):
+    # partial Genes Read-In
+    orf_Lengths = []
+    gene_Lengths = []
+
+    read = False
+    prev = ''
+    for line in results_file:
+        line = line.strip()
+        if read == True:
+            if line.startswith('Gene:'):
+                line = line.replace('Gene:', '')
+                entry = line.split('_')
+                g_Pos = entry[0] + '_' + entry[1]
+                strand = entry[2]
+                prev = 'Gene'
+            elif line.startswith('ORF:'):
+                line = line.replace('ORF:', '')
+                entry = line.split('_')
+                o_Pos = entry[0] + '_' + entry[1]
+                prev = 'ORF'
+            elif line:
+                if 'Gene' in prev:
+                    g_Seq = line.strip()
+                    gene_Lengths.append(len(g_Seq))
+                elif 'ORF' in prev:
+                    o_Seq = line.strip()
+                    orf_Lengths.append(len(o_Seq))
+            elif not line:
+                g_GC = gc_count(g_Seq)
+                o_GC = gc_count(o_Seq)
+                partial_genes.update({g_Pos: [strand, g_Seq, g_GC, o_Pos, o_Seq, o_GC]})
+        if line.startswith('Partial_Gene_Hits:'):
+            read = True
+
+    return partial_genes, orf_Lengths, gene_Lengths
+
+
+def detail_transfer(genes, partial_genes):
+    for partial, m_details in partial_genes.items():
+        try:
+            details = genes[partial]
+            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 partial_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)
+
+    partial_genes = collections.OrderedDict()
+    partial_genes, orf_Lengths, gene_Lengths = partial_gene_read(results_file, partial_genes)
+    orf_Median = np.median(orf_Lengths)
+    gene_Median = np.median(gene_Lengths)
+    strands = collections.defaultdict(int, {'-': 0, '+': 0})
+    # Hard coded codons - Not ideal - default dicts?
+    gene_Starts = collections.OrderedDict(
+        {'ATG': 0, 'ATT': 0, 'CTG': 0, 'GAC': 0, 'GTG': 0, 'TTG': 0, 'ATC': 0, 'ATA': 0})
+    gene_Stops = collections.OrderedDict({'TAA': 0, 'TAG': 0, 'TGA': 0})
+    gene_GC = []
+    orf_Starts = collections.OrderedDict(
+        {'ATG': 0, 'ATT': 0, 'CTG': 0, 'GAC': 0, 'GTG': 0, 'TTG': 0, 'ATC': 0, 'ATA': 0})
+    orf_Stops = collections.OrderedDict({'TAA': 0, 'TAG': 0, 'TGA': 0})
+    orf_GC = []
+
+    for gene, data in partial_genes.items():
+        print(
+            "\nPartial Matched Gene:\t" + gene + "\t" + data[1] + "\nPartial Matched ORF:\t" + data[3] + "\t" + data[4])
+        strands[data[0]] += 1
+        try:
+            gene_Starts[data[1][0:3]] += 1
+            gene_Stops[data[1][-3:]] += 1
+            gene_GC.append(float(data[2]))
+            orf_Starts[data[4][0:3]] += 1
+            orf_Stops[data[4][-3:]] += 1
+            orf_GC.append(float(data[5]))
+        except KeyError:
+            sys.exit("Key Error: " + str(data))
+
+    gene_Median_GC = np.median(gene_GC)
+    orf_Median_GC = np.median(orf_GC)
+    # atg_P = format(100* gene_Starts['ATG'] / len(gene_Lengths),'.2f')
+    # gtg_P = format(100 * gene_Starts['GTG'] / len(gene_Lengths),'.2f')
+    # ttg_P = format(100 * gene_Starts['TTG'] / len(gene_Lengths),'.2f')
+    # att_P = format(100 * gene_Starts['ATT']  / len(gene_Lengths),'.2f')
+    # ctg_P = format(100 * gene_Starts['CTG']  / len(gene_Lengths),'.2f')
+    # #other_Start_P = format(100 * other / len(gene_Lengths),'.2f')
+    #
+    # orf_GC_Median = format(np.median(pcg_GC),'.2f')
+    # num_Short_PCGs = len(short_PCGs)
+    #
+    # partial_genes = detail_transfer(genes,partial_genes)
+
+    g_atg_P, g_gtg_P, g_ttg_P, g_att_P, g_ctg_P = start_Codon_Count(gene_Starts, gene_Lengths)
+    g_tag_P, g_taa_P, g_tga_P = stop_Codon_Count(gene_Stops, gene_Lengths)
+    o_atg_P, o_gtg_P, o_ttg_P, o_att_P, o_ctg_P = start_Codon_Count(orf_Starts, orf_Lengths)
+    o_tag_P, o_taa_P, o_tga_P = stop_Codon_Count(orf_Stops, orf_Lengths)
+
+    # output = ("Number of Protein Coding Genes in " + str(annotation) + " : " + str(len(gene_Lengths)) + ", Median Length of PCGs: " +
+    #           str(gene_Median) + ", Min Length of PCGs: " + str('NA') + ", Max Length of PCGs: " + str('NA') +
+    #           ", Number of PCGs on Pos Strand: " + str(strands['+']) + ", Number of PCGs on Neg Strand: " + str(strands['-']) +
+    #           ", Median GC of PCGs: " + str('NA') +
+    #           ", Number of PCGs less than 100nt: " + str('NA') +
+    output = ("Number of Partial Hits:" + str(len(gene_Lengths)) + "\nMedian Length of Partial Hit Genes:" + str(
+        gene_Median) +
+              '\nMedian Length of Partial Hit ORFs:' + str(orf_Median) + '\nMedian GC Partial Hit Genes:' + str(
+                gene_Median_GC) +
+              '\nMedian GC Partial Hit ORFs:' + str(orf_Median_GC) +
+              '\nPercentage of Genes starting with ATG - Annotation/partial: ' + g_atg_P + ' ' + o_atg_P +
+              '\nPercentage of Genes starting with GTG - Annotation/partial: ' + g_gtg_P + ' ' + o_gtg_P +
+              '\nPercentage of Genes starting with TTG - Annotation/partial: ' + g_ttg_P + ' ' + o_ttg_P +
+              '\nPercentage of Genes starting with ATT - Annotation/partial: ' + g_att_P + ' ' + o_att_P +
+              '\nPercentage of Genes starting with CTG - Annotation/partial: ' + g_ctg_P + ' ' + o_ctg_P +
+              # '\nPercentage of Genes starting with Alternative Start Codon - Annotation/partial: ' + other_Starts_P + ' ' + m_other_Stops_P +
+              '\nPercentage of Genes ending with TAG - Annotation/partial: ' + g_tag_P + ' ' + o_tag_P +
+              '\nPercentage of Genes ending with TAA - Annotation/partial: ' + g_taa_P + ' ' + o_taa_P +
+              '\nPercentage of Genes ending with TGA - Annotation/partial: ' + g_tga_P + ' ' + o_tga_P)
+    # '\nPercentage of Genes ending with Alternative Stop Codon - Annotation/partial: ' + other_Stops_P + ' ' + m_other_Stops_P)
+
+    print(output)
+
+    # import matplotlib.pylab as plt
+    #
+    # list_ORF_Starts = list(orf_Starts.items())  # sorted by key, return a list of tuples
+    # list_Gene_Starts = list(gene_Starts.items())
+    # o_x, o_y = zip(*list_ORF_Starts)  # unpack a list of pairs into two tuples
+    # g_x, g_y = zip(*list_Gene_Starts)
+    #
+    # plt.plot(o_x, o_y)
+    # plt.plot(g_x, g_y)
+    # plt.show()
+    #
+    # list_ORF_Stops = list(orf_Stops.items())  # sorted by key, return a list of tuples
+    # list_Gene_Stops = list(gene_Stops.items())
+    # o_x, o_y = zip(*list_ORF_Stops)  # unpack a list of pairs into two tuples
+    # g_x, g_y = zip(*list_Gene_Stops)
+    #
+    # plt.plot(o_x, o_y)
+    # plt.plot(g_x, g_y)
+    # plt.show()
+
+
+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)

ORForise/ORForise_Analysis/result_File_Analysis.py

@@ -0,0 +1,286 @@
+import copy
+
+import argparse
+import collections
+
+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 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 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 get_genome(genome):
+    genome_Seq = ""
+    with open('../Genomes/' + genome + '.fa', 'r') as genome:
+        for line in genome:
+            line = line.replace("\n", "")
+            if not line.startswith('>'):
+                genome_Seq += str(line)
+    return genome_Seq
+
+
+def missed_genes_in(genes_detected, missed_genes, results_in):
+    # Missed Genes Read-In
+    read = False
+    for line in results_in:
+        line = line.strip()
+        if read == True:
+            if line.startswith('>'):
+                entry = line.split('_')
+                entry = entry[1] + '_' + entry[2]
+                strand = entry[-1]
+                if int(strand) <= 2:
+                    strand = '+'
+                else:
+                    strand = '-'
+            elif len(line.strip()) > 0:
+                startCodon = line[0:3]
+                stopCodon = line[-3:]
+                length = len(line)
+                missed_genes.update({entry: [line, strand, length, startCodon, stopCodon]})
+
+        if line.startswith('Undetected_Genes:'):
+            read = True
+        if read == True and not line:
+            break
+    list_Missed = list(missed_genes.keys())
+    for key in list_Missed:
+        # ### printed out to confirm figure lengths
+        # start = key.split('_')[0]
+        # stop = key.split('_')[1]
+        if key in genes_detected:
+            del genes_detected[key]
+
+    return missed_genes, genes_detected
+
+
+def partial_matches_in(partial_matches, results_in):
+    # partial Genes Read-In
+    read = False
+    prev = ''
+    for line in results_in:
+        line = line.strip()
+        if read == True:
+            if line.startswith('Gene:'):
+                line = line.replace('Gene:', '')
+                entry = line.split('_')
+                g_Pos = entry[0] + '_' + entry[1]
+                strand = entry[2]
+                prev = 'Gene'
+            elif line.startswith('ORF:'):
+                line = line.replace('ORF:', '')
+                entry = line.split('_')
+                o_Pos = entry[0] + '_' + entry[1]
+                prev = 'ORF'
+            elif line:
+                if 'Gene' in prev:
+                    g_Seq = line.strip()
+                    g_length = len(g_Seq)
+                elif 'ORF' in prev:
+                    o_Seq = line.strip()
+                    orf_length = len(o_Seq)
+            elif not line:
+                partial_matches.update({g_Pos: [strand, g_length, g_Seq, o_Pos, orf_length, o_Seq]})
+        if line.startswith('Partial_Gene_Hits:'):
+            read = True
+
+    return partial_matches
+
+
+def unmatched_ORFs_in(unmatched_ORFs, results_file):
+    # Unmatched ORFs Read-In
+    read = False
+    for line in results_file:
+        line = line.strip()
+        if read == True:
+            if line.startswith('>'):
+                line = line.replace('Gene:', '')
+                entry = line.split('_')
+                strand = entry[-1]
+                o_Pos = entry[1] + '_' + entry[2]
+                unmatched_ORFs.update({o_Pos: [strand, None, None, None, None]})
+            elif line:
+                o_Seq = line.strip()
+                o_Length = len(o_Seq)
+                startCodon = line[0:3]
+                stopCodon = line[-3:]
+                unmatched_ORFs.update({o_Pos: [strand, o_Length, o_Seq, startCodon, stopCodon]})
+        if line.startswith('ORF_Without_Corresponding_Gene_in_Ensembl:'):
+            read = True
+        elif read == True and not line:
+            unmatched_ORFs.update({o_Pos: [strand, o_Length, o_Seq, startCodon, stopCodon]})
+            break
+
+    return unmatched_ORFs
+
+
+def genes_in(genome, genome_Seq, genome_Seq_Rev, genome_Size, genes):
+    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]
+                    length = stop - start
+                    gene = str(start) + '_' + str(stop)
+                    if '+' in strand:
+                        seq = genome_Seq[start - 1:stop]
+                    elif '-' in strand:
+                        r_Start = genome_Size - stop
+                        r_Stop = genome_Size - start
+                        seq = genome_Seq_Rev[r_Start:r_Stop + 1]
+                    startCodon = seq[0:3]
+                    stopCodon = seq[-3:]
+                    genes.update({gene: [seq, strand, length, startCodon, stopCodon]})
+            except IndexError:
+                continue
+    return genes
+
+
+def extract_results(genome, results_file):
+    genome_Seq = get_genome(genome)
+    genome_Seq_Rev = revCompIterative(genome_Seq)
+    genome_Size = len(genome_Seq)
+    genes = collections.OrderedDict()
+    partial_matches = collections.OrderedDict()
+    missed_genes = collections.OrderedDict()
+    unmatched_ORFs = collections.OrderedDict()
+
+    genes = genes_in(genome, genome_Seq, genome_Seq_Rev, genome_Size, genes)
+    genes_detected = copy.deepcopy(genes)
+    missed_genes, genes_detected = missed_genes_in(genes_detected, missed_genes, results_file)
+    results_file.seek(0, 0)  # Reset file position
+    partial_matches = partial_matches_in(partial_matches, results_file)
+    results_file.seek(0, 0)  # Reset file position
+    unmatched_ORFs = unmatched_ORFs_in(unmatched_ORFs, results_file)
+    results_file.seek(0, 0)  # Reset file position
+
+    return genes, genes_detected, missed_genes, partial_matches, unmatched_ORFs
+
+
+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')
+
+    genes, genes_detected, missed_genes, partial_matches, unmatched_ORFs = extract_results(genome, results_file)
+    gene_Lengths, genes_detected_Lengths, missed_Lengths, partial_Lengths, unmatched_Lengths = [], [], [], [], []
+
+    for pos in genes.keys():
+        gene_Lengths.append(int(pos.split('_')[1]) - int(pos.split('_')[0]))
+    for pos in genes_detected.keys():
+        genes_detected_Lengths.append(int(pos.split('_')[1]) - int(pos.split('_')[0]))
+    for pos in partial_matches.keys():
+        partial_Lengths.append(int(pos.split('_')[1]) - int(pos.split('_')[0]))
+    for pos in missed_genes.keys():
+        missed_Lengths.append(int(pos.split('_')[1]) - int(pos.split('_')[0]))
+    for pos in unmatched_ORFs.keys():
+        unmatched_Lengths.append(int(pos.split('_')[1]) - int(pos.split('_')[0]))
+
+    import numpy as np
+
+    print(len(gene_Lengths))
+    print(gene_Lengths)
+    print(np.mean(gene_Lengths))
+    print(len(partial_Lengths))
+    print(partial_Lengths)
+    print(len(missed_Lengths))
+    print(missed_Lengths)
+    print(len(unmatched_Lengths))
+    print(unmatched_Lengths)
+    print(np.mean(unmatched_Lengths))

ORForise/ORForise_Analysis/start_Codon_Substitution.py

@@ -0,0 +1,161 @@
+import argparse
+import collections
+
+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 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 partial_gene_read(results_file, partial_genes):
+    # partial Genes Read-In
+    orf_Lengths = []
+    gene_Lengths = []
+    read = False
+    prev = ''
+    for line in results_file:
+        line = line.strip()
+        if read == True:
+            if line.startswith('Gene:'):
+                line = line.replace('Gene:', '')
+                entry = line.split('_')
+                g_Pos = entry[0] + '_' + entry[1]
+                strand = entry[2]
+                prev = 'Gene'
+            elif line.startswith('ORF:'):
+                line = line.replace('ORF:', '')
+                entry = line.split('_')
+                o_Pos = entry[0] + '_' + entry[1]
+                prev = 'ORF'
+            elif line:
+                if 'Gene' in prev:
+                    g_Seq = line.strip()
+                    gene_Lengths.append(len(g_Seq))
+                elif 'ORF' in prev:
+                    o_Seq = line.strip()
+                    orf_Lengths.append(len(o_Seq))
+            elif not line:
+                partial_genes.update({g_Pos: [strand, g_Seq, o_Pos, o_Seq]})
+        if line.startswith('Partial_Gene_Hits:'):
+            read = True
+    return partial_genes, orf_Lengths, gene_Lengths
+
+
+def perfect_Matches(results_file, perfect_Match_Genes):
+    read = False
+    for line in results_file:
+        line = line.strip()
+        if read == True:
+            if line.startswith('>'):
+                entry = line.split('_')
+                g_Pos = entry[1] + '_' + entry[2]
+                strand = entry[3]
+            elif line:
+                g_Seq = line
+                g_Start = line[0:3]
+                g_Stop = line[-3:]
+            elif not line:
+                perfect_Match_Genes.update({g_Pos: [strand, g_Seq, g_Start, g_Stop]})
+        if line.startswith('Perfect_Match_Genes:'):
+            read = True
+        if line.startswith('Undetected_Genes'):
+            break
+    return perfect_Match_Genes
+
+
+def detail_transfer(genes, partial_genes):
+    for partial, m_details in partial_genes.items():
+        try:
+            details = genes[partial]
+            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 partial_genes
+
+
+def result_compare(results_file, genome_file):
+    genome = ""
+    with open('../Genomes/' + genome_file + '.fa', 'r') as genome_file:
+        for line in genome_file:
+            line = line.replace("\n", "")
+            if ">" not in line:
+                genome += str(line)
+
+    partial_genes = collections.OrderedDict()
+    perfect_Match_Genes = collections.OrderedDict()
+    partial_genes, orf_Lengths, gene_Lengths = partial_gene_read(results_file, partial_genes)
+    results_file.seek(0)
+    perfect_Match_Genes = perfect_Matches(results_file, perfect_Match_Genes)
+
+    perfect_Match_Gene_Start_Codons = collections.OrderedDict({'ATG': 0, 'GTG': 0, 'TTG': 0, 'CTG': 0, 'Other': 0})
+    for gene, data in perfect_Match_Genes.items():
+        try:
+            perfect_Match_Gene_Start_Codons[data[2]] += 1
+        except  KeyError:
+            perfect_Match_Gene_Start_Codons['Other'] += 1
+    print("Perfect Match Start Codons\nATG:" + str(perfect_Match_Gene_Start_Codons['ATG']) + ",GTG:" + str(
+        perfect_Match_Gene_Start_Codons['GTG']) + ",TTG:" +
+          str(perfect_Match_Gene_Start_Codons['TTG']) + ",CTG:" + str(
+        perfect_Match_Gene_Start_Codons['CTG']) + ",Other_Start:" + str(perfect_Match_Gene_Start_Codons['Other']))
+
+    strands = collections.defaultdict(int, {'-': 0, '+': 0})
+    start_Codon_Substitution = collections.OrderedDict(
+        {'ATG-ATG': 0, 'GTG-ATG': 0, 'TTG-ATG': 0, 'CTG-ATG': 0, 'Alt-ATG': 0,
+         'ATG-GTG': 0, 'GTG-GTG': 0, 'TTG-GTG': 0, 'CTG-GTG': 0, 'Alt-CTG': 0,
+         'ATG-TTG': 0, 'GTG-TTG': 0, 'TTG-TTG': 0, 'CTG-TTG': 0, 'Alt-GTG': 0,
+         'ATG-CTG': 0, 'GTG-CTG': 0, 'TTG-CTG': 0, 'CTG-CTG': 0, 'Alt-TTG': 0,
+         'ATG-Alt': 0, 'GTG-Alt': 0, 'TTG-Alt': 0, 'CTG-Alt': 0, 'Alt-Alt': 0})
+
+    codon_set = ['ATG', 'CTG', 'GTG', 'TTG']
+    for gene, data in partial_genes.items():
+        strands[data[0]] += 1
+        gene_Start = [data[1][0:3]]
+        orf_Start = [data[3][0:3]]
+        if gene_Start[0] in codon_set:
+            gene_Start = gene_Start[0]
+        else:
+            print('Gene_Codon_Alternative:' + str(gene_Start[0]))
+            gene_Start = 'Alt'
+        if orf_Start[0] in codon_set:
+            orf_Start = orf_Start[0]
+        else:
+            print('ORF_Codon_Alternative:' + str(orf_Start[0]))
+            orf_Start = 'Alt'
+
+        matrix_index = gene_Start + '-' + orf_Start
+        start_Codon_Substitution[matrix_index] += 1
+
+    ####### HERE - Need to flip the data  - GS along the top
+    subs = start_Codon_Substitution.values()
+    subs = list(subs)
+    subs[:0] = ['ATG', 'GTG', 'TTG', 'CTG', 'Other']
+    for i in [subs[c:c + 5] for c in range(0, len(subs), 5) if c % 5 == 0]:
+        print(*i)
+
+
+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(results_file, genome)