ORForise 1.6.2__py3-none-any.whl

ORForise/Aux/StORF_Undetected/Completely_Undetected/Completey_Undetected.py

@@ -0,0 +1,53 @@
+import argparse
+
+from orderedset import OrderedSet
+
+parser = argparse.ArgumentParser()
+parser.add_argument('-i', '--undetected_Genes', default='', help='Undected Genes.')
+parser.add_argument('-t', '--tool', default='', help='Tool Used.')
+args = parser.parse_args()
+
+
+def un_Genes(undetected_Genes, tool_ORFs):
+    count = 0
+    genes = []
+    with open(undetected_Genes, 'r') as undected_GFF:
+        for line in undected_GFF:
+            if ">" in line:
+                line = line.split('_')
+                g_start = int(line[1])
+                g_stop = int(line[2])
+                gene_ORF = str(g_start) + ',' + str(g_stop)
+                genes.append(gene_ORF)
+                gene_Set = OrderedSet(range(g_start, g_stop + 1))
+                for t_ORF in tool_ORFs:
+                    t_ORF = t_ORF.split(',')
+                    t_start = int(t_ORF[0])
+                    t_stop = int(t_ORF[1])
+                    tool_Set = OrderedSet(range(t_start - 0, t_stop + 1))
+                    overlap = len(tool_Set.intersection(gene_Set))
+                    if overlap >= 1:
+                        print(overlap)
+                        print(line)
+                        count += 1
+                        break
+    print(
+        "Number of Undetected Genes: " + str(len(genes)) + " Number of Spoiled Undetected Genes By Tool: " + str(count))
+
+
+def tool(tool, undetected_Genes):
+    tool_ORFs = []
+    with open(tool, 'r') as input:
+        for line in input:
+            line = line.split()
+            if "Prodigal" in line[1] and "CDS" in line[2]:  # Modify For Tool
+                t_start = int(line[3])
+                t_stop = int(line[4])
+                tool_ORF = str(t_start) + ',' + str(t_stop)
+                tool_ORFs.append(tool_ORF)
+
+    un_Genes(undetected_Genes, tool_ORFs)
+
+
+if __name__ == "__main__":
+    tool(**vars(args))

ORForise/Aux/StORF_Undetected/StORF_Undetected.py

@@ -0,0 +1,35 @@
+import collections
+
+try:
+    from utils import revCompIterative
+    from utils import sortORFs
+except ImportError:
+    from ORForise.utils import revCompIterative
+    from ORForise.utils import sortORFs
+
+
+def StORF_Undetected(tool_pred, genome):
+    storf_orfs = collections.OrderedDict()
+    genome_size = len(genome)
+    genome_Rev = revCompIterative(genome)
+    with open(tool_pred, 'r') as storf_input:
+        for line in storf_input:
+            line = line.split()
+            if "StORF" in line[1] and "ORF" 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 - 1 + 3]
+                    stopCodon = genome[stop - 3:stop - 1 + 1]
+                po = str(start) + ',' + str(stop)
+                orf = [strand, startCodon, stopCodon]
+                storf_orfs.update({po: orf})
+
+    storf_orfs = sortORFs(storf_orfs)
+    return storf_orfs

ORForise/Aux/StORF_Undetected/unvitiated_Genes/unvitiated_Missed_Genes.py

@@ -0,0 +1,46 @@
+import argparse
+import collections
+
+parser = argparse.ArgumentParser()
+parser.add_argument('-mg', '--missing_genes', default='', help='Which set of genes to check?')
+parser.add_argument('-g', '--genome_to_compare', required=True,
+                    help='Which genome to analyse? Genome files have same prefix'
+                         ' - .fa and .gff appended')
+args = parser.parse_args()
+
+
+def comparator(missing_genes, genome_to_compare):
+    missed_genes = collections.OrderedDict()
+    non_vitiated_genes = []
+    with open('../' + missing_genes, 'r') as m_genes:
+        for line in m_genes:
+            if line.startswith('>'):
+                line = line.split('_')
+                start = int(line[1])
+                stop = int(line[2])
+                m_gene_Set = set(range(start, stop + 1))
+                missed_genes.update({str(start) + '_' + str(stop): m_gene_Set})
+                non_vitiated_genes.append(str(start) + '_' + str(stop))
+    ##############################################
+
+    with open('../../Prodigal/Prodigal_' + genome_to_compare + '.gff', 'r') as prodigal_input:
+        for line in prodigal_input:
+            line = line.split()
+            if "Prodigal" in line[1] and "CDS" in line[2]:
+                start = int(line[3])
+                stop = int(line[4])
+                pred_set = set(range(start, stop + 1))
+                for missed, g_set in missed_genes.items():
+                    overlap = len(pred_set.intersection(g_set))
+                    if overlap > 50:
+                        print(start)
+                        try:
+                            non_vitiated_genes.remove(missed)
+                            print(missed)
+                        except ValueError:
+                            continue
+    print(len(non_vitiated_genes))
+
+
+if __name__ == "__main__":
+    comparator(**vars(args))

ORForise/Aux/TabToGFF/TabToGFF.py

@@ -0,0 +1,140 @@
+import collections
+import logging
+
+
+
+def _make_feature(seqid, source, type_, start, end, score, strand, phase, attributes):
+    attrs = []
+    for k, v in attributes.items():
+        attrs.append(f"{k}={v}")
+    return f"{seqid}\t{source}\t{type_}\t{start}\t{end}\t{score}\t{strand}\t{phase}\t{';'.join(attrs)}\n"
+
+
+def parse_blast_tab6(path, genome_seq, gene_ident=None):
+    results = collections.OrderedDict()
+    count = 0
+    with open(path, 'r') as fh:
+        for i, line in enumerate(fh, 1):
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            parts = line.split('\t')
+            if len(parts) < 12:
+                logging.warning(f"Line {i}: unexpected BLAST line with {len(parts)} columns")
+                continue
+            qseqid, sseqid, pident, length, mismatch, gapopen, qstart, qend, sstart, send, evalue, bitscore = parts[:12]
+            try:
+                sstart = int(sstart)
+                send = int(send)
+            except ValueError:
+                logging.warning(f"Line {i}: non-integer coordinates in BLAST sstart/send")
+                continue
+            start = min(sstart, send)
+            end = max(sstart, send)
+            strand = '+' if sstart <= send else '-'
+            attrs = {
+                'ID': f'blast_hit{count}',
+                'Target': f'{qseqid} {qstart} {qend}',
+                'pident': pident,
+                'length': length,
+                'evalue': evalue,
+                'bitscore': bitscore
+            }
+            results[f"{start},{end}"] = [strand, '.', 'similarity', attrs]
+            count += 1
+    return results
+
+
+def parse_abricate(path, genome_seq, gene_ident=None):
+    results = collections.OrderedDict()
+    count = 0
+    with (open(path, 'r') as fh):
+        header = None
+        for i, line in enumerate(fh, 1):
+            line = line.rstrip('\n')
+            if not line:
+                continue
+            if line.startswith('#'):
+                header = line.split('\t')
+                continue
+            if header is None:
+                # skip any pre-header content until a header line is encountered
+                continue
+            parts = line.split('\t')
+            if header and len(parts) == len(header):
+                row = dict(zip(header, parts))
+
+                try:
+                    start = int(row.get('START', '0'))
+                    end = int(row.get('END', '0'))
+                    strand = row.get('STRAND')
+                except ValueError:
+                    logging.warning(f"Line {i}: invalid START/END in Abricate line")
+                    continue
+                seqid = row.get('SEQUENCE')
+                gene = row.get('GENE')
+                accession =  row.get('ACCESSION') or 'unknown'
+                db = row.get('DATABASE')  or 'unknown'
+                identity = row.get('%IDENTITY')
+                coverage = row.get('%COVERAGE')
+                product = row.get('PRODUCT') or 'unkown'
+                resistance = row.get('RESISTANCE') or 'unknown'
+
+                attrs = {
+                    'seqid': seqid,
+                    'start': start,
+                    'end': end,
+                    'strand': strand,
+                    'gene': gene,
+                    'accession': accession,
+                    'database': db,
+                    'identity': identity,
+                    'coverage': coverage,
+                    'product': product,
+                    'resistance': resistance
+                }
+                results[f"{start},{end}"] = attrs
+                count += 1
+            else:
+                logging.warning(f"Line {i}: unexpected number of columns in Abricate line")
+                continue
+    return results
+
+
+def parse_genemark(path, genome_seq, gene_ident=None):
+    results = collections.OrderedDict()
+    count = 0
+    with open(path, 'r') as fh:
+        for i, line in enumerate(fh, 1):
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.split()
+            if len(parts) < 3:
+                continue
+            try:
+                start = int(parts[0])
+                stop = int(parts[1])
+            except ValueError:
+                continue
+            strand_tok = parts[2]
+            if 'complement' in strand_tok:
+                strand = '-'
+            else:
+                strand = '+'
+            attrs = {'ID': f'genemark_hit{count}', 'tool': 'GeneMark'}
+            results[f"{start},{stop}"] = [strand, '.', 'CDS', attrs]
+            count += 1
+    return results
+
+
+def TabToGFF(input_file, genome_seq, gene_ident='CDS', fmt='blast'):
+    # Should be cleaned up to use consistent format names
+    fmt = fmt.lower()
+    if fmt in ('blast', 'blast_tab6', 'tab6'):
+        return parse_blast_tab6(input_file, genome_seq, gene_ident)
+    if fmt in ('abricate', 'abricate_tsv', 'abricate_format'):
+        return parse_abricate(input_file, genome_seq, gene_ident)
+    if fmt in ('genemark', 'gene_mark'):
+        return parse_genemark(input_file, genome_seq, gene_ident)
+    raise ValueError(f"Unknown format: {fmt}")