def main(argv=None):
"""script main.
parses command line options in sys.argv, unless *argv* is given.
"""
if argv == None: argv = sys.argv
parser = E.OptionParser(
version=
"%prog version: $Id: gpipe/compare_predictions2exons.py 2011 2008-07-04 10:40:51Z andreas $",
usage=globals()["__doc__"])
parser.add_option("-g",
"--genome-file",
dest="genome_file",
type="string",
help="filename with genome.")
parser.add_option("-b",
"--boundaries",
dest="filename_boundaries",
type="string",
help="filename with exon boundaries.")
parser.add_option("-e",
"--exons",
dest="filename_exons",
type="string",
help="filename with exons (output).")
parser.add_option("-p",
"--peptides",
dest="filename_peptides",
type="string",
help="filename with peptide sequences.")
parser.add_option(
"-w",
"--write-notfound",
dest="write_notfound",
action="store_true",
help="print exons for predictions not found in reference.")
parser.add_option("-q",
"--quality-pide",
dest="quality_threshold_pide",
type="int",
help="quality threshold (pide) for exons.")
parser.set_defaults(
genome_file="genome",
filename_boundaries=None,
filename_exons=None,
filename_peptides=None,
quality_threshold_pide=0,
write_notfound=False,
## allowed number of nucleotides for exon boundaries to
## be considered equivalent.
slipping_exon_boundary=9,
## stop codons to search for
stop_codons=("TAG", "TAA", "TGA"),
)
(options, args) = E.Start(parser, add_pipe_options=True)
if len(args) > 0:
print USAGE, "no arguments required."
sys.exit(2)
reference_exon_boundaries = {}
if options.filename_boundaries:
reference_exon_boundaries = Exons.ReadExonBoundaries(open(
options.filename_boundaries, "r"),
do_invert=1,
remove_utr=1)
E.info("read exon boundaries for %i queries" %
len(reference_exon_boundaries))
if options.filename_exons:
outfile_exons = open(options.filename_exons, "w")
outfile_exons.write("%s\n" % "\t".join(
("prediction_id", "exon_id", "exon_from", "exon_to", "exon_frame",
"reference_id", "reference_from", "reference_to",
"reference_phase", "pidentity", "psimilarity", "nframeshifts",
"ngaps", "nstopcodons", "is_ok", "genome_exon_from",
"genome_exon_to")))
else:
outfile_exons = None
if options.filename_peptides:
peptide_sequences = Genomics.ReadPeptideSequences(
open(options.filename_peptides, "r"))
E.info("read peptide sequences for %i queries" %
len(peptide_sequences))
else:
peptide_sequences = {}
entry = PredictionParser.PredictionParserEntry()
last_filename_genome = None
nfound, nmissed_exons, nmissed_length = 0, 0, 0
nempty_alignments = 0
fasta = IndexedFasta.IndexedFasta(options.genome_file)
options.stdout.write("%s\n" % "\t".join(
("prediction_id", "number", "dubious_exons", "boundaries_sum",
"boundaries_max", "identical_exons", "inserted_exons",
"deleted_exons", "inserted_introns", "deleted_introns",
"truncated_Nterminus", "truncated_Cterminus", "deleted_Nexons",
"deleted_Cexons", "inserted_Nexons", "inserted_Cexons")))
for line in sys.stdin:
if line[0] == "#": continue
try:
entry.Read(line)
except ValueError, msg:
print "# parsing failed with msg %s in line %s" % (msg, line[:-1])
sys.exit(1)
exons = Genomics.Alignment2ExonBoundaries(
entry.mMapPeptide2Genome,
query_from=entry.mQueryFrom,
sbjct_from=entry.mSbjctGenomeFrom,
add_stop_codon=0)
if exons[-1][4] != entry.mSbjctGenomeTo:
print "# WARNING: discrepancy in exon calculation!!!"
for e in exons:
print "#", str(e)
print "#", str(entry)
if options.loglevel >= 5:
for e in exons:
print "#", str(e)
genomic_fragment = fasta.getSequence(entry.mSbjctToken,
entry.mSbjctStrand,
entry.mSbjctGenomeFrom,
entry.mSbjctGenomeTo)
skip = False
if peptide_sequences.has_key(entry.mQueryToken):
query_sequence = alignlib_lite.makeSequence(
peptide_sequences[entry.mQueryToken])
sbjct_sequence = alignlib_lite.makeSequence(entry.mTranslation)
percent_similarity, percent_identity = 0, 0
if query_sequence.getLength(
) < entry.mMapPeptide2Translation.getRowTo():
print "# WARNING: query sequence %s is too short: %i %i" % (
entry.mQueryToken, query_sequence.getLength(),
entry.mMapPeptide2Translation.getRowTo())
sys.stdout.flush()
nmissed_length += 1
skip = True
elif sbjct_sequence.getLength(
) < entry.mMapPeptide2Translation.getColTo():
print "# WARNING: sbjct sequence %s is too short: %i %i" % (
entry.mSbjctToken, sbjct_sequence.getLength(),
entry.mMapPeptide2Translation.getColTo())
sys.stdout.flush()
nmissed_length += 1
skip = True
else:
alignlib_lite.rescoreAlignment(
entry.mMapPeptide2Translation, query_sequence,
sbjct_sequence,
alignlib_lite.makeScorer(query_sequence, sbjct_sequence))
percent_identity = alignlib_lite.calculatePercentIdentity(
entry.mMapPeptide2Translation, query_sequence,
sbjct_sequence) * 100
percent_similarity = alignlib_lite.calculatePercentSimilarity(
entry.mMapPeptide2Translation) * 100
E.debug(
"prediction %s: percent identity/similarity: before=%5.2f/%5.2f, realigned=%5.2f/%5.2f"
%
(str(entry.mPredictionId), entry.mPercentSimilarity,
entry.mPercentIdentity, percent_similarity, percent_identity))
else:
query_sequence = None
sbjct_sequence = None
# default values
exons_num_exons = "na"
exons_boundaries_sum = "na"
exons_boundaries_max = "na"
dubious_exons = "na"
ndeleted_exons, ninserted_exons, ndeleted_introns, ninserted_introns, nidentical_exons = 0, 0, 0, 0, 0
truncated_Nterminal_exon, truncated_Cterminal_exon = 0, 0
ndeleted_Nexons, ndeleted_Cexons = 0, 0
ninserted_Nexons, ninserted_Cexons = 0, 0
exons_offset = exons[0][3]
if not reference_exon_boundaries.has_key(entry.mQueryToken):
print "# WARNING: sequence %s has no exon boundaries" % (
entry.mQueryToken)
sys.stdout.flush()
nmissed_exons += 1
skip = True
if not skip:
nfound += 1
ref_exons = reference_exon_boundaries[entry.mQueryToken]
ref_exons_offset = ref_exons[0].mGenomeFrom
exons_num_exons = len(ref_exons) - len(exons)
exons_boundaries_sum = 0
exons_phase = 0
exons_boundaries_max = 0
dubious_exons = 0
inserted_exons = 0
temp_inserted_exons = 0
if options.loglevel >= 3:
for e in exons:
options.stdlog.write("# %s\n" % str(e))
for e in ref_exons:
options.stdlog.write("# %s\n" % str(e))
min_pide = entry.mPercentIdentity * options.quality_threshold_pide / 100
in_sync = 0
e, r = 0, 0
while e < len(exons) and r < len(ref_exons):
this_e, this_r = e + 1, r + 1
percent_identity = 0
percent_similarity = 0
is_good_exon = 0
if options.loglevel >= 4:
options.stdlog.write("# current exons: %i and %i\n" %
(e, r))
sys.stdout.flush()
exon_from, exon_to, exon_phase, exon_genome_from, exon_genome_to, exon_ali = exons[
e][0:6]
ref_from, ref_to, ref_phase, ref_genome_from, ref_genome_to = (
ref_exons[r].mPeptideFrom, ref_exons[r].mPeptideTo,
ref_exons[r].frame, ref_exons[r].mGenomeFrom,
ref_exons[r].mGenomeTo)
ref_genome_from -= ref_exons_offset
ref_genome_to -= ref_exons_offset
## get percent identity for exon
exon_percent_identity = 0
exon_percent_similarity = 0
if query_sequence and sbjct_sequence:
tmp_ali = alignlib_lite.makeAlignmentVector()
xquery_from = exon_from / 3
xquery_to = exon_to / 3
alignlib_lite.copyAlignment(tmp_ali,
entry.mMapPeptide2Translation,
xquery_from, xquery_to)
if tmp_ali.getLength() == 0:
options.stdlog.write(
"# WARNING: empty alignment %s\n" % str(
(ref_from, exon_from, ref_to, exon_to,
xquery_from, xquery_to)))
nempty_alignments += 1
else:
if options.loglevel >= 5:
options.stdlog.write("# %s\n" % str(
alignlib_lite.AlignmentFormatExplicit(
tmp_ali, query_sequence, sbjct_sequence)))
exon_percent_identity = alignlib_lite.calculatePercentIdentity(
tmp_ali, query_sequence, sbjct_sequence) * 100
exon_percent_similarity = alignlib_lite.calculatePercentSimilarity(
tmp_ali) * 100
if exon_percent_identity >= min_pide:
is_good_exon = 1
else:
is_good_exon = 0
if e < len(exons) - 1:
(next_exon_from, next_exon_to, next_exon_phase,
next_exon_genome_from, next_exon_genome_to,
next_exon_ali) = exons[e + 1][0:6]
else:
(next_exon_from, next_exon_to, next_exon_phase,
next_exon_genome_from, next_exon_genome_to,
next_exon_ali) = 0, 0, 0, 0, 0, []
if r < len(ref_exons) - 1:
next_ref_from, next_ref_to, next_ref_phase = (
ref_exons[r + 1].mPeptideFrom,
ref_exons[r + 1].mPeptideTo, ref_exons[r + 1].frame)
else:
next_ref_from, next_ref_to, next_ref_phase = 0, 0, 0
if options.loglevel >= 2:
options.stdlog.write("# %s\n" % "\t".join(
map(str, (entry.mQueryToken, exon_from, exon_to,
exon_phase, exon_genome_from, exon_genome_to,
ref_from, ref_to, ref_phase))))
sys.stdout.flush()
# beware of small exons.
# if less than options.slipping_exon_boundary: boundary is 0
# check if end is more than options.splipping_exon_boundary apart as well.
if exon_to - exon_from <= options.slipping_exon_boundary or \
ref_to - ref_from <= options.slipping_exon_boundary:
boundary = 0
else:
boundary = options.slipping_exon_boundary
if ref_to <= exon_from + boundary and \
ref_to <= exon_to - options.slipping_exon_boundary:
## no overlap
is_good_exon = 0
if e == 0:
ndeleted_Nexons += 1
else:
ndeleted_exons += 1
r += 1
exon_from, exon_to, exon_phase, exon_genome_from, exon_genome_to = 0, 0, 0, 0, 0
overlap = 0
elif exon_to <= ref_from + boundary and \
exon_to <= ref_to - options.slipping_exon_boundary:
## no overlap
is_good_exon = 0
if r == 0:
ninserted_Nexons += 1
else:
ninserted_exons += 1
e += 1
ref_from, ref_to, ref_phase = 0, 0, 0
overlap = 0
else:
## overlap
overlap = 1
dfrom = int(math.fabs(exon_from - ref_from))
dto = int(math.fabs(exon_to - ref_to))
## get percent identity for overlapping fragment
if query_sequence and sbjct_sequence:
## this the problem
tmp_ali = alignlib_lite.makeAlignmentVector()
xquery_from = max(ref_from / 3, exon_from / 3)
xquery_to = min(ref_to / 3, exon_to / 3)
alignlib_lite.copyAlignment(
tmp_ali, entry.mMapPeptide2Translation,
xquery_from, xquery_to)
if tmp_ali.getLength() == 0:
options.stdlog.write(
"# warning: empty alignment %s\n" % str(
(ref_from, exon_from, ref_to, exon_to,
xquery_from, xquery_to)))
percent_identity = 0
percent_similarity = 0
else:
if options.loglevel >= 5:
print str(
alignlib_lite.AlignmentFormatExplicit(
tmp_ali, query_sequence,
sbjct_sequence))
percent_identity = alignlib_lite.calculatePercentIdentity(
tmp_ali, query_sequence, sbjct_sequence) * 100
percent_similarity = alignlib_lite.calculatePercentSimilarity(
tmp_ali) * 100
if percent_identity >= min_pide:
is_good_exon = 1
else:
is_good_exon = 0
dubious_exons += 1
## adjust regions for terminal exons
if e == 0 and r == 0 and dfrom <= (entry.mQueryFrom -
1) * 3 and dfrom > 0:
if is_good_exon:
truncated_Nterminal_exon = dfrom
dfrom = 0
## truncated terminal exons
if e == len(exons) - 1 and r == len(
ref_exons) - 1 and dto <= (
entry.mQueryLength -
entry.mQueryTo) * 3 and dto > 0:
if is_good_exon:
truncated_Cterminal_exon = dto
dto = 0
## do not count deviations for terminal query exons
if e == 0 and dfrom <= entry.mQueryFrom * 3 and dfrom > 0:
dfrom = 0
if e == len(exons) - 1 and dto <= (
entry.mQueryLength -
entry.mQueryTo) * 3 and dto > 0:
dto = 0
## permit difference of one codon (assumed to be stop)
if e == len(exons) - 1 and r == len(
ref_exons) - 1 and dto == 3:
dto = 0
## deal with different boundary conditions:
if dfrom == 0 and dto == 0:
if is_good_exon: nidentical_exons += 1
e += 1
r += 1
## next exon within this ref_exon
elif exon_to < ref_to and next_exon_to and next_exon_to <= ref_to + options.slipping_exon_boundary:
if is_good_exon: ninserted_introns += 1
e += 1
in_sync = 1
dto = 0
## next ref_exon within this exon
elif ref_to < exon_to and next_ref_to and next_ref_to <= exon_to + options.slipping_exon_boundary:
if is_good_exon: ndeleted_introns += 1
r += 1
in_sync = 1
dto = 0
else:
e += 1
r += 1
if in_sync:
dfrom = 0
if is_good_exon:
exons_boundaries_sum += dfrom + dto
exons_boundaries_max = max(dfrom, exons_boundaries_max)
exons_boundaries_max = max(dto, exons_boundaries_max)
###########################################################
## count inserted/deleted introns and misplaced boundaries
##
## if exon and next_exon in ref_exon: inserted intron
## if ref_exon and next_ref_exon in exon: deleted intron
if outfile_exons:
if genomic_fragment and exon_genome_to:
nintrons, nframeshifts, ngaps, nsplits, nstopcodons, disruptions = Genomics.CountGeneFeatures(
exon_genome_from - entry.mSbjctGenomeFrom,
exon_ali,
genomic_fragment,
border_stop_codon=0)
else:
nintrons, nframeshifts, ngaps, nsplits, nstopcodons = 0, 0, 0, 0, 0
if exon_to == 0: this_e = 0
if ref_to == 0: this_r = 0
outfile_exons.write(
string.join(
map(str, (
entry.mPredictionId,
this_e,
exon_from,
exon_to,
exon_phase,
this_r,
ref_from,
ref_to,
ref_phase,
percent_identity,
percent_similarity,
nframeshifts,
ngaps,
nstopcodons,
is_good_exon,
exon_genome_from,
exon_genome_to,
)), "\t") + "\n")
while e < len(exons):
exon_from, exon_to, exon_phase, exon_genome_from, exon_genome_to = exons[
e][0:5]
e += 1
ninserted_Cexons += 1
if outfile_exons:
outfile_exons.write(
string.join(
map(str, (
entry.mPredictionId,
e,
exon_from,
exon_to,
exon_phase,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
exon_genome_from,
exon_genome_to,
)), "\t") + "\n")
while r < len(ref_exons):
ref_from, ref_to, ref_phase, ref_genome_from, ref_genome_to = (
ref_exons[r].mPeptideFrom, ref_exons[r].mPeptideTo,
ref_exons[r].frame, ref_exons[r].mGenomeFrom,
ref_exons[r].mGenomeTo)
ndeleted_Cexons += 1
ref_genome_from -= ref_exons_offset
ref_genome_to -= ref_exons_offset
r += 1
if outfile_exons:
outfile_exons.write(
string.join(
map(str, (
entry.mPredictionId,
0,
0,
0,
0,
r,
ref_from,
ref_to,
ref_phase,
0,
0,
0,
0,
0,
0,
0,
0,
)), "\t") + "\n")
else:
if options.write_notfound:
this_e = 0
## use prediction's identity/similarity for exons.
## This will still then flag stop-codons in later analysis
percent_identity = entry.mPercentIdentity
percent_similarity = entry.mPercentSimilarity
for exon in exons:
this_e += 1
exon_from, exon_to, exon_phase, exon_genome_from, exon_genome_to, exon_ali = exon[
0:6]
if genomic_fragment:
nintrons, nframeshifts, ngaps, nsplits, nstopcodons, disruptions = Genomics.CountGeneFeatures(
exon_genome_from - entry.mSbjctGenomeFrom,
exon_ali, genomic_fragment)
outfile_exons.write(
string.join(
map(str, (
entry.mPredictionId,
this_e,
exon_from,
exon_to,
exon_phase,
0,
0,
0,
0,
percent_identity,
percent_similarity,
nframeshifts,
ngaps,
nstopcodons,
1,
exon_genome_from,
exon_genome_to,
)), "\t") + "\n")
options.stdout.write("\t".join(
map(str, (entry.mPredictionId, exons_num_exons, dubious_exons,
exons_boundaries_sum, exons_boundaries_max,
nidentical_exons, ninserted_exons, ndeleted_exons,
ninserted_introns, ndeleted_introns,
truncated_Nterminal_exon, truncated_Cterminal_exon,
ndeleted_Nexons, ndeleted_Cexons, ninserted_Nexons,
ninserted_Cexons))) + "\n")
def main(argv=None):
"""script main.
parses command line options in sys.argv, unless *argv* is given.
"""
if argv is None:
argv = sys.argv
parser = E.OptionParser(
version=
"%prog version: $Id: gpipe/gff2predictions.py 2021 2008-07-10 16:00:48Z andreas $",
usage=globals()["__doc__"])
parser.add_option("-t",
"--trans",
dest="trans",
help="input is translated DNA.",
action="store_true")
parser.add_option("-f",
"--format",
dest="format",
help="input format.",
type="choice",
choices=("exons", "psl", "gff"))
parser.add_option("-o",
"--output-format",
dest="output_format",
help="output format",
type="choice",
choices=('exontable', 'exons', 'predictions', 'cds',
'fasta'))
parser.add_option("-g",
"--genome-file",
dest="genome_file",
type="string",
help="filename with genomic data (indexed).")
parser.add_option(
"--predictions-file",
dest="predictions_file",
type="string",
help=
"filename with predictions. Use gene structures from this file if available."
)
parser.add_option("-i",
"--gff-field-id",
dest="gff_field_id",
type="string",
help="field for the feature id in the gff info section.")
parser.add_option(
"-p",
"--filename-peptides",
dest="filename_peptides",
type="string",
help=
"Filename with peptide sequences. If given, it is used to check the predicted translated sequences."
)
parser.add_option(
"--no-realignment",
dest="do_realignment",
action="store_false",
help="do not re-align entries that do not parse correctly.")
parser.add_option(
"--remove-unaligned",
dest="remove_unaligned",
action="store_true",
help="remove entries that have not been aligned correctly.")
parser.add_option(
"--input-coordinates",
dest="input_coordinates",
type="string",
help=
"specify input format for input coordinates [forward|both-zero|one-closed|open]."
)
parser.set_defaults(trans=False,
output_format="predictions",
format="psl",
gff_field_id='id',
input_coordinates="both-zero-open",
filename_peptides=None,
genome_file=None,
do_realignment=True,
predictions_file=None,
remove_unaligned=False)
(options, args) = E.Start(parser)
if not options.genome_file:
raise "please specify a genome file."
fasta = IndexedFasta.IndexedFasta(options.genome_file)
contig_sizes = fasta.getContigSizes()
ninput, noutput, nskipped = 0, 0, 0
nfound, nnotfound, nidentical, nmismatch, naligned, nunaligned = 0, 0, 0, 0, 0, 0
if options.filename_peptides:
peptide_sequences = Genomics.ReadPeptideSequences(
IOTools.openFile(options.filename_peptides, "r"))
predictor = Predictor.PredictorExonerate()
predictor.mLogLevel = 0
else:
peptide_sequences = None
predictor = None
converter = IndexedFasta.getConverter(options.input_coordinates)
predictions = {}
if options.predictions_file:
parser = PredictionParser.iterator_predictions(
IOTools.openFile(options.predictions_file, "r"))
for p in parser:
predictions[p.mPredictionId] = p
if options.output_format == "predictions":
if options.format == "psl":
if options.trans:
parser = PredictionParser.PredictionParserBlatTrans()
else:
parser = PredictionParser.PredictionParserBlatCDNA()
nmatches = 1
for line in sys.stdin:
if line[0] == "#":
continue
if not re.match("^[0-9]", line):
continue
try:
entries = parser.Parse((line, ))
except PredictionParser.AlignmentError, e:
print "# %s" % str(e)
print "#", line[:-1]
sys.exit(1)
for entry in entries:
entry.mPredictionId = nmatches
nmatches += 1
print str(entries)
elif options.format == "exons":
parser = PredictionParser.PredictionParserExons(
contig_sizes=contig_sizes)
else:
raise "unknown format %s for output option %s" % (
options.format, options.output_format)
if options.loglevel >= 2:
options.stdlog.write("# parsing.\n")
options.stdlog.flush()
results = parser.Parse(sys.stdin.readlines())
if options.loglevel >= 2:
options.stdlog.write("# parsing finished.\n")
options.stdlog.flush()
if options.loglevel >= 1:
options.stdlog.write(
"# parsing: ninput=%i, noutput=%i, nerrors=%i\n" %
(parser.GetNumInput(), parser.GetNumOutput(),
parser.GetNumErrors()))
for error, msg in parser.mErrors:
options.stdlog.write("# %s : %s\n" % (str(error), msg))
options.stdlog.flush()
# if genomes are given: build translation
if options.genome_file:
results.Sort(lambda x, y: cmp(x.mSbjctToken, y.mSbjctToken))
new_results = PredictionParser.Predictions()
for entry in results:
ninput += 1
if options.loglevel >= 2:
options.stdlog.write(
"# processing entry %s:%s on %s:%s %i/%i.\n" %
(entry.mPredictionId, entry.mQueryToken,
entry.mSbjctToken, entry.mSbjctStrand, ninput,
len(results)))
options.stdlog.flush()
try:
lgenome = fasta.getLength(entry.mSbjctToken)
# added 3 residues - was a problem at split codons just before the stop.
# See for example the chicken sequence ENSGALP00000002741
genomic_sequence = fasta.getSequence(
entry.mSbjctToken, entry.mSbjctStrand,
entry.mSbjctGenomeFrom,
min(entry.mSbjctGenomeTo + 3, lgenome))
except KeyError:
if options.loglevel >= 1:
options.stdlog.write(
"# did not find entry for %s on %s.\n" %
(entry.mPredictionId, entry.mSbjctToken))
nskipped += 1
continue
if predictions and entry.mPredictionId in predictions:
if options.loglevel >= 2:
options.stdlog.write(
"# substituting entry %s on %s:%s.\n" %
(entry.mPredictionId, entry.mSbjctToken,
entry.mSbjctStrand))
options.stdlog.flush()
entry = predictions[entry.mPredictionId]
exons = Exons.Alignment2Exons(entry.mMapPeptide2Genome, 0,
entry.mSbjctGenomeFrom)
entry.mMapPeptide2Translation, entry.mTranslation = Genomics.Alignment2PeptideAlignment(
Genomics.String2Alignment(entry.mAlignmentString),
entry.mQueryFrom, 0, genomic_sequence)
entry.score = entry.mMapPeptide2Translation.getColTo(
) - entry.mMapPeptide2Translation.getColFrom() + 1
(entry.mNIntrons, entry.mNFrameShifts, entry.mNGaps, entry.mNSplits, entry.mNStopCodons, entry.mNDisruptions ) = \
Genomics.CountGeneFeatures(0,
entry.mMapPeptide2Genome,
genomic_sequence)
if peptide_sequences:
if str(entry.mPredictionId) in peptide_sequences:
reference = peptide_sequences[str(
entry.mPredictionId)].upper()
translation = entry.mTranslation
nfound += 1
is_identical, nmismatches = checkIdentity(
reference, translation, options)
if is_identical:
nidentical += 1
else:
nmismatch += 1
if options.do_realignment:
if options.loglevel >= 2:
options.stdlog.write(
"# %s: mismatches..realigning in region %i:%i\n"
% (entry.mPredictionId,
entry.mSbjctGenomeFrom,
entry.mSbjctGenomeTo))
options.stdlog.flush()
result = predictor(
entry.mPredictionId, reference,
entry.mSbjctToken, genomic_sequence,
"--subopt FALSE --score '%s'" %
str(80))
# "--exhaustive --subopt FALSE --score '%s'" % str(80) )
if result:
translation = result[0].mTranslation
is_identical, nmismatches = checkIdentity(
reference, translation, options)
else:
if options.loglevel >= 2:
options.stdlog.write(
"# %s: realignment returned empty result\n"
% (entry.mPredictionId))
options.stdlog.flush()
is_identical = False
if is_identical:
naligned += 1
prediction_id = entry.mPredictionId
sbjct_genome_from = entry.mSbjctGenomeFrom
entry = result[0]
entry.mPredictionId = prediction_id
entry.mSbjctGenomeFrom += sbjct_genome_from
else:
nunaligned += 1
if options.loglevel >= 1:
options.stdlog.write(
"# %s: mismatch on %s:%s:%i-%i after realignment\n# reference =%s\n# translated=%s\n# realigned =%s\n"
%
(entry.mPredictionId,
entry.mSbjctToken,
entry.mSbjctStrand,
entry.mSbjctGenomeFrom,
entry.mSbjctGenomeTo,
reference, entry.mTranslation,
translation))
options.stdlog.flush()
if options.remove_unaligned:
nskipped += 1
continue
else:
if options.loglevel >= 2:
options.stdlog.write(
"# %s: mismatches on %s ... no realignment\n"
% (
entry.mPredictionId,
entry.mSbjctToken,
))
if options.loglevel >= 3:
options.stdlog.write(
"# %s: mismatch before realignment\n# reference =%s\n# translated=%s\n"
% (entry.mPredictionId, reference,
translation))
options.stdlog.flush()
if options.remove_unaligned:
nskipped += 1
continue
else:
nnotfound += 1
new_results.append(entry)
noutput += 1
results = new_results
if results:
options.stdout.write(str(results) + "\n")
def main( argv = None ):
"""script main.
parses command line options in sys.argv, unless *argv* is given.
"""
if argv == None: argv = sys.argv
parser = E.OptionParser( version = "%prog version: $Id: gpipe/predictions2disruptions.py 2781 2009-09-10 11:33:14Z andreas $")
parser.add_option("-g", "--genome-file", dest="genome_file", type="string",
help="filename with genome pattern." )
parser.add_option( "--start-codon-boundary", dest="start_codon_boundary", type="int",
help="maximum extension for start codon (make divisible by 3)." )
parser.add_option( "--stop-codon-boundary", dest="stop_codon_boundary", type="int",
help="maximum extension for stop codon (make divisible by 3)." )
parser.set_defaults(
genome_file = "genome.fasta",
stop_codons = ("TAG", "TAA", "TGA")
)
(options, args) = E.Start( parser, add_pipe_options = True )
if len(args) > 0:
print USAGE, "no arguments required."
sys.exit(2)
p = PredictionParser.PredictionParserEntry()
fasta = IndexedFasta.IndexedFasta( options.genome_file )
for line in sys.stdin:
if line[0] == "#": continue
p.Read(line)
genomic_sequence = fasta.getSequence( p.mSbjctToken, p.mSbjctStrand,
p.mSbjctGenomeFrom, p.mSbjctGenomeTo )
if options.loglevel >= 2:
options.stdlog.write ("# parsing alignment %s\n" % p.mAlignmentString)
try:
nintrons, nframeshifts, ngaps, nsplits, nstopcodons, disruptions =\
Genomics.CountGeneFeatures( 0,
p.mMapPeptide2Genome,
genomic_sequence,
border_stop_codon = 0,
stop_codons = options.stop_codons )
except ValueError, msg:
options.stderr.write( "# parsing error: %s in line %s\n" % (line[:-1], msg))
sys.exit(1)
for type, \
cds_pos_from, cds_pos_to, \
genome_pos_from, genome_pos_to in disruptions:
options.stdout.write( "\t".join(map(str, (p.mPredictionId,
type,
cds_pos_from, cds_pos_to,
genome_pos_from + p.mSbjctGenomeFrom,
genome_pos_to + p.mSbjctGenomeFrom) ) )+ "\n")
options.stdout.flush()
def main(argv=None):
"""script main.
parses command line options in sys.argv, unless *argv* is given.
"""
if argv is None:
argv = sys.argv
parser = E.OptionParser(
version=
"%prog version: $Id: mali2predictions.py 2781 2009-09-10 11:33:14Z andreas $",
usage=globals()["__doc__"])
parser.add_option("-g",
"--genome-file",
dest="genome_file",
type="string",
help="filename with genome.")
parser.add_option("-l",
"--filename-locations",
dest="filename_locations",
type="string",
help="filename with locations")
parser.add_option("-m",
"--master",
dest="master",
type="string",
help="the master determines the frame.")
parser.set_defaults(filename_locations=None, gap_chars="-.", master=None)
(options, args) = E.Start(parser, add_pipe_options=True)
if len(args) > 0:
print USAGE, "no arguments required."
sys.exit(2)
mali = Mali.Mali()
mali.readFromFile(sys.stdin)
identifiers = mali.getIdentifiers()
aligned_columns, aligned_exons = getAlignedColumns(mali, options)
map_id2location = {}
if options.filename_locations:
map_id2location = IOTools.ReadMap(open(options.filename_locations,
"r"))
options.stdout.write(Prediction.Prediction().getHeader() + "\n")
nid = 1
for identifier in identifiers:
if options.loglevel >= 2:
options.stdlog.write("# processing %s\n" % (identifier))
entry = mali.getEntry(identifier)
sequence = entry.mString
if sequence[0] not in string.lowercase:
raise "all sequences should start with an exon."
was_exon = True
d = 0
alignment = []
carry_over = 0
last_codon = []
codon = []
nchars_in_codon = 0
n = 0
last_master_residue = 0
master_residue = 0
for column in range(len(sequence)):
c = sequence[column]
is_gap = c in options.gap_chars
is_aligned = column in aligned_columns
is_exon = column in aligned_exons
if is_gap:
continue
if is_exon:
master_residue = aligned_exons[column]
codon.append((n, master_residue))
n += 1
# check if we have a complete codon
if is_exon:
# A codon is complete, if it ends at frame 2 or
# it spans more than one codons in the master.
# Gaps in the master that are a multiple of 3 are ignored
d = master_residue - last_master_residue - 1
if master_residue % 3 == 2 or (d % 3 != 0 and d > 0):
if last_codon:
d = codon[0][0] - last_codon[-1][0] - 1
if d > 0:
# add in-frame introns
if d > 10:
alignment.append(["5", 0, 2])
alignment.append(["I", 0, d - 4])
alignment.append(["3", 0, 2])
else:
raise "untreated case"
alignment += processCodon(codon)
last_codon = codon
codon = []
last_master_residue = master_residue
last = alignment[0]
new_alignment = []
for this in alignment[1:]:
if this[0] == last[0]:
last[1] += this[1]
last[2] += this[2]
continue
new_alignment.append(last)
last = this
new_alignment.append(last)
if options.loglevel >= 4:
options.stdlog.write("# output=%s\n" % (str(new_alignment)))
assert (new_alignment[-1][2] % 3 == 0)
lalignment = sum(map(lambda x: x[2], new_alignment))
prediction = Prediction.Prediction()
prediction.mQueryToken = identifier
genomic_sequence = re.sub("[%s]" % options.gap_chars, "",
mali[identifier])
prediction.mPredictionId = nid
nid += 1
if identifier in map_id2location:
prediction.mSbjctToken, prediction.mSbjctStrand, sfrom, sto = map_id2location[
identifier].split(":")[:4]
prediction.mSbjctGenomeFrom = int(sfrom) + entry.mFrom
prediction.mSbjctGenomeTo = int(sto)
else:
prediction.mSbjctToken = "unk"
prediction.mSbjctStrand = "+"
prediction.mSbjctGenomeFrom = 0
prediction.mQueryCoverage = 100
prediction.mPercentIdentity = 100
prediction.mPercentSimilarity = 100
prediction.mQueryLength = prediction.mQueryTo
prediction.mSbjctGenomeTo = prediction.mSbjctGenomeFrom + lalignment
prediction.mMapPeptide2Genome = new_alignment
prediction.mAlignmentString = string.join(
map(lambda x: string.join(map(str, x), " "),
prediction.mMapPeptide2Genome), " ")
prediction.mMapPeptide2Translation, prediction.mTranslation = Genomics.Alignment2PeptideAlignment(
prediction.mMapPeptide2Genome, 0, 0, genomic_sequence)
(prediction.mNIntrons, prediction.mNFrameShifts, prediction.mNGaps, prediction.mNSplits, prediction.mNStopCodons, disruptions) = \
Genomics.CountGeneFeatures(0,
prediction.mMapPeptide2Genome,
genomic_sequence)
options.stdout.write(str(prediction) + "\n")
E.Stop()
