### TO DO: implement all codon tables (default is 5, major alternatives are: 2,4,9,13, minor alternatives are 14,24,33)

## Need pref_code update for each ttable - check if this would be enough.

import sys

import re

import os

from Bio.SeqUtils import nt_search, seq3

import RNA

from Bio.Seq import reverse_complement

RNA.cvar.temperature = 20

#do_filter = False

do_filter = True

deepverbose = True

deepverbose = False

verbose = False

#verbose = True

## structure sanitization procedure:

## -do not touch *[ nn] characters in the first pass, only spaces

## -replace each *[ nn]* with '.'*nn string (by slice-in) in structure only (second pass)

## -global bracket adjustment still needed

## After that, refolding should not happen

def sanitize_structure(x,y): #x structure, y sequence

return x,y

def acodon_loop(s): #find position of anticodon loop in a structure

return left+1,right-1,good #the extra margin around stem. May need to be removed if some aa is not found.

###MAIN

if len(sys.argv) < 2:

print 'usage: python t2gff.py fasta_filename ttable_id'

else:

file_path = sys.argv[1]

seqid = file_path.split(".",1)[0]

ttable_id = sys.argv[2]

temp_file = 'tmp.fa'

fasta_file = seqid + '.fa'

with open(fasta_file, 'r') as f:

contents = f.read()

linie = contents.split('\n')

sequence_len = len(''.join(linie[1:]))

with open(temp_file, 'w') as f:

f.write('>' + seqid + '\n')

f.write('\n'.join(linie[1:]))

f.write('\n'.join(linie[1])) ## dirty hack to cover circular cases

## true sequence is in linie[1:], true length is also correct

## for simplicity we store the "extended" version for slicing

extended_seq = ''.join(linie[1:])+linie[1]

# print extended_seq

file_path = seqid + '.cms'

if not (os.path.isfile(file_path)):

command = 'cmscan trn_a.cm ' + temp_file + '> ' + file_path

os.system(command)

os.remove(temp_file)

else:

print 'Re-using ', file_path

relaxed = ['!','?']

pref_code5 = {'F':'TGAAR','C':'TGCAR','Y':'TGTAR','H':'TGTGR','D':'TGTCR','I':'TGATR','N':'TGTTR','L1':'YTAAR','S1':'TTGAR','W':'TTCAR','P':'TTGGR','R':'TTCGR','Q':'TTTGR','V':'TTACR','A':'TTGCR','G':'TTCCR','E':'TTTCR','T':'TTGTR','K':'TTTTR','M':'YCATR','M2':'YTATR','L2':'YTAGR','S2':'TKCTR'}

pref_code2 = {'F':'TGAAR','C':'TGCAR','Y':'TGTAR','H':'TGTGR','D':'TGTCR','I':'TGATR','N':'TGTTR','L1':'YTAAR','S1':'TTGAR','W':'TTCAR','P':'TTGGR','R':'TTCGR','Q':'TTTGR','V':'TTACR','A':'TTGCR','G':'TTCCR','E':'TTTCR','T':'TTGTR','K':'TTTTR','M':'YCATR','L2':'YTAGR','S2':'TRCTR','M2':'YTATR'}

pref_code4 = {'F':'TGAAR','C':'TGCAR','Y':'TGTAR','H':'TGTGR','D':'TGTCR','I':'TDATR','N':'TGTTR','L1':'YTAAR','S1':'TTGAR','W':'TTCAR','P':'TTGGR','R1':'TTCGR','Q':'TTTGR','V':'TTACR','A':'TTGCR','G':'TTCCR','E':'TTTCR','T':'TTGTR','K':'TTTTR','M':'YCATR','R2':'YYCTR','L2':'YTAGR','S2':'TRCTR'}

pref_code9 = {'F':'TGAAR','C':'TGCAR','Y':'TGTAR','H':'TGTGR','D':'TGTCR','I':'YDATR','N':'TDTTR','L1':'YTAAR','S1':'TTGAR','W':'TTCAR','P':'TTGGR','R':'TTCGR','Q':'TTTGR','V':'TTACR','A':'TTGCR','G':'TTCCR','E':'TYTCR','T':'TTGTR','K':'TCTTR','M':'YCATR','L2':'YTAGR','S2':'TKCTR'}

pref_code13 = {'F':'TGAAR','C':'TGCAR','Y':'TGTAR','H':'TGTGR','D':'TGTCR','I':'TGATR','N':'TGTTR','L1':'YTAAR','S1':'TTGAR','W':'TTCAR','P':'TTGGR','R':'TTCGR','Q':'TTTGR','V':'TTACR','A':'TTGCR','G1':'TTCCR','E':'TTTCR','T':'TTGTR','K':'TTTTR','M':'YCATR','M2':'YTATR','L2':'YTAGR','S2':'TRCTR','G2':'YYCTR'}

if ttable_id == '2':

pref_code = pref_code2

elif ttable_id == '4':

pref_code = pref_code4

elif ttable_id == '9':

pref_code = pref_code9

elif ttable_id == '13':

pref_code = pref_code13

else:

pref_code = pref_code5

with open(file_path, 'r') as file_input:

infernal_data = file_input.read()

data = infernal_data.split("Hit alignments:",1)

genes = data[1].split("\n>> ")

list_of_records = []

# parse the main output from cms file into memory, store all important data in a list of records

# each record is also a list:

# product(string)[0],

# possible_aa(list of strings)[1],

# start(string)[2],

# end(string)[3],

# score(string)[4],

# possible_anticodon(list of strings)[5],

# retain(boolean)[6],

# strand(string)[7]

for gene in genes[1:]:

linia = gene.split('\n')

column = linia[3].split()

if column[1] in relaxed:

## cmscan stores reversed start/end coordinates for '-' strand

## better to correct this immediately, make sure it is consistent

start = column[9]

end = column[10]

score = column[3]

strand = column[11]

if strand == '-':

start = column[10]

end = column[9]

product = linia[0].strip()

## now parse structure and sequence (aln)

structure = linia[6].rstrip(' CS')

aln = linia[9].upper().replace('U','T')

short_structure = structure.lstrip()

offset = len(structure) - len(short_structure)

structure = short_structure

aln = aln[offset:len(structure)+offset]

## need conversion to common coordinates/lengths

if deepverbose: print '\nstructure:',structure,'\n aln:',aln

(better_structure, better_aln) = sanitize_structure(structure,aln)

structure = better_structure

aln = better_aln

if 'N' in aln.upper():

#indicative of excessive sanitization, replace with true sequence

true_aln = extended_seq[int(start)-1:int(end)]

if strand == '-':

true_aln = reverse_complement(true_aln)

aln = true_aln.upper()

aln_len = int(end) - int(start) +1

if len(aln) == aln_len == len(structure):

if deepverbose: print len(aln),len(structure)

mfe = RNA.energy_of_structure(aln.replace('T','U'),structure.replace('<','(').replace('>',')'),0)

elif int(start) <= sequence_len: #final sanity check, should never happen

if verbose: print "can't adopt cmscan structure. Re-folding at", start, end

(structure, mfe) = RNA.fold(aln)

score = -1*mfe

# if mfe > 0:

# print 'adjusting score'

# score = 0

if verbose:

print ''

print product

print structure,start,end

print aln, score

#now guess anticodon and possible_aa based on pref code table (dictionary)

left,right,not_bad = acodon_loop(structure)

possible_aa = []

possible_anticodon = []

possible_offset = []

possible_structure = []

no_left_arm= 'S' in product

if not_bad:

# bad case happens if anticodon loop is not found, record will not be stored

# try to minimize those by sophisticating detection

if verbose: print 'not bad',

for aa in pref_code:

hits = nt_search(aln[left:right], pref_code[aa])

if len(hits) >1:

possible_aa.append(aa)

offset = int(hits[1]) + left

# offset = int(hits[1]) + left + 1

##this is not used internally so must be in non-pythonic coordinates! Add "1" for pythonic god!

possible_offset.append(offset)

possible_anticodon.append(aln[offset+1:offset+4])

if verbose: print aa,aln[offset+1:offset+4],

#ended up with 3 lists in the same order:

#one with possible aa [0]

#the second with respective (real) anticodons [4],

#third with their relative positions [6]

#make separate record for each valid aa+anticodon combination

#avoiding the need for sanitization of product

# the original product is entirely ignored...

if len(possible_aa) > 0:

for i in range(0, len(possible_aa)):

dane_do_zapisu = [possible_aa[i], start, end, score, possible_anticodon[i], strand, possible_offset[i], structure]

list_of_records.append(dane_do_zapisu)

if verbose: print '\naccepted', possible_aa[i],

else:

if verbose: print 'no aa...', aln,aln[left:right],pref_code

#filter out nearly identical hits: similar location, same aa and anticodon

# there is something wrong with this procedure... It leaves true identical records... Why?

# same record in checked and accepted gets duplicated somehow?

# to prevent this from happening the results should be stored in a dictionary structure, not a list

# keyed by the defining elements: 0, 1,2,3(?),4,5... possibly 6 (same as in filtering step)

if verbose: print '\n',len(list_of_records),'records before filter'

if do_filter:

delta=10 ##This needs tuning...here orelse during clustering this should approach half of the usual trn length...

checked = []

accepted = []

while len(list_of_records) > 0:

rec1=list_of_records.pop()

best =True

for rec2 in list_of_records+checked:

ovlap = ((abs(int(rec1[1]) - int(rec2[1])) < delta) and (abs(int(rec1[2]) - int(rec2[2])) < delta))

same = (rec1[0]==rec2[0]) and (rec1[4] == rec2[4])

if ovlap and same and float(rec1[3]) < float(rec2[3]):## which location is retained?...

if deepverbose: print 'duplicate',rec1[0:5]

best = False

break

if best and not (rec1 in accepted):

accepted.append(rec1)

checked.append(rec1)

list_of_records = accepted

if verbose: print len(list_of_records), 'in the middle'

# accepted = [list_of_records.pop()]

accepted = []

while len(list_of_records) > 0:

r = list_of_records.pop(0)

duplicate = False

for q in accepted:

if r[0:6]==q[0:6]:

duplicate =True

break

if not duplicate:

accepted.append(r)

list_of_records = sorted(accepted, key = lambda x: float(x[3]), reverse = True)

if verbose: print len(list_of_records),'after filter'

with open(seqid + ".gff", 'a') as gff:

for rec in list_of_records:

strand = rec[5]

start = rec[1]

end = rec[2]

aux = 'product=tRNA-' + seq3(rec[0][0]) + ';anticodon=(' + rec[4].lower() + ');anticodon_position=' + str(rec[6]) +';label=' + rec[0] + ';structure='+rec[7]

linia_output = seqid + '\t' + 'infernal\ttRNA' + '\t' + start + '\t' + end + '\t' + str(rec[3]) + '\t' + strand + '\t.\t' + aux + '\n'

if int(start) <= sequence_len:

gff.write(linia_output)