def process_tags(self):
"""Processes the tags in the input data for analysis.
"""
s = self._spats
pair_db = self._pair_db
s.loadTargets(pair_db)
s.run.pair_length = pair_db.pair_length()
p = s._processor
for target in pair_db.targets():
p.addTagTarget(target[0], target[1])
p.addTagTarget(target[0] + "_rc", reverse_complement(str(target[1])))
p.addTagTarget("adapter_t_rc", reverse_complement(s.run.adapter_t))
p.addTagTarget("adapter_b", s.run.adapter_b)
if s.run.cotrans:
p.addTagTarget("linker_cotrans", s.run.cotrans_linker)
p.addTagTarget("linker_cotrans_rc", reverse_complement(s.run.cotrans_linker))
for tag in self._extra_tag_targets:
p.addTagTarget(tag[0], tag[1])
for tag, handler in self._plugins.iteritems():
p.addTagPlugin(tag, handler)
s.process_pair_db(pair_db, batch_size = 10000)
self.result_set_id = pair_db.result_set_id_for_name(s.run.result_set_name)
pair_db.count_tags(self.result_set_id)
pair_db.store_run(s.run)
def test_SRPs(self):
self.assertEqual(self.target.find_partial(reverse_complement("GGGCCTGACTCGGGCACCAAGGACGGGTGGGGGCC"))[1:], [0, 31, 106]) #R1 0_0
self.assertEqual(self.target.find_partial(reverse_complement("CCCGCTGACTCGGGCACCAAGGACGGGTGGGGGCC"))[1:], [0, 31, 106]) #R1 0_1
self.assertEqual(self.target.find_partial(reverse_complement("CCCGCTGACTCGGGCACCAAGGACGGGTGGGGGCC"))[1:], [0, 31, 106]) #R1 106
self.assertEqual(self.target.find_partial(reverse_complement("GGGCCTGACTCGGGCACCAAGGACGGGTGGGGGCA"))[1:], [1, 30, 107]) #R1 107
self.assertEqual(self.target.find_partial(reverse_complement("GGGCCTGACTCGGGCACCAAGGACAGATCGGAAGA"))[1:], [11, 20, 117]) #R1 117
self.assertEqual(self.target.find_partial("ATCGGGGGCTCTGTTGGTTCTCCCGCAACGCTACT")[1:], [0, 35, 0]) #R2 0_0
self.assertEqual(self.target.find_partial("ATCGGGGGCTCTGTTGGTTCTCCCGCAACGCTACT")[1:], [0, 35, 0]) #R2 0_1
self.assertEqual(self.target.find_partial("GCAGGGCCCCCACCCGTCCTTGGTGCCCGAGTCAG")[1:], [0, 35, 102]) #R2 102
self.assertEqual(self.target.find_partial("CAGGGCCCCCACCCGTCCTTGGTGCCCGAGTCAGG")[1:], [0, 34, 103]) #R2 103
self.assertEqual(self.target.find_partial("GGCCCCCACCCGTCCTTGGTGCCCGAGTCAGGCCC")[1:], [0, 31, 106]) #R2 106
self.assertEqual(self.target.find_partial("GCCCCCACCCGTCCTTGGTGCCCGAGTCAGGCCCA")[1:], [0, 30, 107]) #R2 107
self.assertEqual(self.target.find_partial("GTCCTTGGTGCCCGAGTCAGGCCCAGATCGGAAGA")[1:], [0, 20, 117]) #R2 117
def tags():
bp = "/Users/jbrink/mos/tasks/1RwIBa/tmp/datasets/cotrans/"
from spats_shape_seq.db import PairDB
pair_db = PairDB(bp + "db/pairs.db")
if True:
print "Parsing to db..."
pair_db.wipe()
pair_db.add_targets_table(bp + "cotrans_single.fa")
pair_db.parse(bp + "data/EJS_6_F_10mM_NaF_Rep1_GCCAAT_R1.fastq",
bp + "data/EJS_6_F_10mM_NaF_Rep1_GCCAAT_R2.fastq",
sample_size=100000)
from spats_shape_seq import Spats
from spats_shape_seq.tag import TagProcessor
from spats_shape_seq.util import reverse_complement
s = Spats()
s.run._processor_class = TagProcessor
s.run.writeback_results = True
s.run.result_set_name = "tags"
s.run.num_workers = 1
s.run.cotrans = True
s.run.cotrans_linker = 'CTGACTCGGGCACCAAGGAC'
s.loadTargets(pair_db)
s.run.allow_indeterminate = True
s.run.allowed_target_errors = 2
s.run.allowed_adapter_errors = 2
p = s._processor
for target in pair_db.targets():
p.addTagTarget(target[0], target[1])
p.addTagTarget(target[0] + "_rc", reverse_complement(target[1]))
p.addTagTarget("adapter_t_rc", reverse_complement(s.run.adapter_t))
p.addTagTarget("adapter_b", s.run.adapter_b)
if s.run.cotrans:
p.addTagTarget("linker_cotrans", s.run.cotrans_linker)
p.addTagTarget("linker_cotrans_rc",
reverse_complement(s.run.cotrans_linker))
s.process_pair_db(pair_db)
rsid = pair_db.result_set_id_for_name(s.run.result_set_name)
pair_db.count_tags(rsid)
print pair_db.tag_counts(rsid)
def tags():
bp = "/Users/jbrink/mos/tasks/1RwIBa/tmp/datasets/cotrans/"
from spats_shape_seq.db import PairDB
pair_db = PairDB(bp + "db/pairs.db")
if True:
print "Parsing to db..."
pair_db.wipe()
pair_db.add_targets_table(bp + "cotrans_single.fa")
pair_db.parse(bp + "data/EJS_6_F_10mM_NaF_Rep1_GCCAAT_R1.fastq",
bp + "data/EJS_6_F_10mM_NaF_Rep1_GCCAAT_R2.fastq",
sample_size = 100000)
from spats_shape_seq import Spats
from spats_shape_seq.tag import TagProcessor
from spats_shape_seq.util import reverse_complement
s = Spats()
s.run._processor_class = TagProcessor
s.run.writeback_results = True
s.run.result_set_name = "tags"
s.run.num_workers = 1
s.run.cotrans = True
s.run.cotrans_linker = 'CTGACTCGGGCACCAAGGAC'
s.loadTargets(pair_db)
s.run.allow_indeterminate = True
s.run.allowed_target_errors = 2
s.run.allowed_adapter_errors = 2
p = s._processor
for target in pair_db.targets():
p.addTagTarget(target[0], target[1])
p.addTagTarget(target[0] + "_rc", reverse_complement(target[1]))
p.addTagTarget("adapter_t_rc", reverse_complement(s.run.adapter_t))
p.addTagTarget("adapter_b", s.run.adapter_b)
if s.run.cotrans:
p.addTagTarget("linker_cotrans", s.run.cotrans_linker)
p.addTagTarget("linker_cotrans_rc", reverse_complement(s.run.cotrans_linker))
s.process_pair_db(pair_db)
rsid = pair_db.result_set_id_for_name(s.run.result_set_name)
pair_db.count_tags(rsid)
print pair_db.tag_counts(rsid)
def test_SRPs(self):
self.assertEqual(
self.target.find_partial(
reverse_complement("GGGCCTGACTCGGGCACCAAGGACGGGTGGGGGCC"))[1:],
[0, 31, 106]) #R1 0_0
self.assertEqual(
self.target.find_partial(
reverse_complement("CCCGCTGACTCGGGCACCAAGGACGGGTGGGGGCC"))[1:],
[0, 31, 106]) #R1 0_1
self.assertEqual(
self.target.find_partial(
reverse_complement("CCCGCTGACTCGGGCACCAAGGACGGGTGGGGGCC"))[1:],
[0, 31, 106]) #R1 106
self.assertEqual(
self.target.find_partial(
reverse_complement("GGGCCTGACTCGGGCACCAAGGACGGGTGGGGGCA"))[1:],
[1, 30, 107]) #R1 107
self.assertEqual(
self.target.find_partial(
reverse_complement("GGGCCTGACTCGGGCACCAAGGACAGATCGGAAGA"))[1:],
[11, 20, 117]) #R1 117
self.assertEqual(
self.target.find_partial("ATCGGGGGCTCTGTTGGTTCTCCCGCAACGCTACT")
[1:], [0, 35, 0]) #R2 0_0
self.assertEqual(
self.target.find_partial("ATCGGGGGCTCTGTTGGTTCTCCCGCAACGCTACT")
[1:], [0, 35, 0]) #R2 0_1
self.assertEqual(
self.target.find_partial("GCAGGGCCCCCACCCGTCCTTGGTGCCCGAGTCAG")
[1:], [0, 35, 102]) #R2 102
self.assertEqual(
self.target.find_partial("CAGGGCCCCCACCCGTCCTTGGTGCCCGAGTCAGG")
[1:], [0, 34, 103]) #R2 103
self.assertEqual(
self.target.find_partial("GGCCCCCACCCGTCCTTGGTGCCCGAGTCAGGCCC")
[1:], [0, 31, 106]) #R2 106
self.assertEqual(
self.target.find_partial("GCCCCCACCCGTCCTTGGTGCCCGAGTCAGGCCCA")
[1:], [0, 30, 107]) #R2 107
self.assertEqual(
self.target.find_partial("GTCCTTGGTGCCCGAGTCAGGCCCAGATCGGAAGA")
[1:], [0, 20, 117]) #R2 117
def align_pairs():
from spats_shape_seq.pair import Pair
from spats_shape_seq.target import Targets
from spats_shape_seq.util import reverse_complement, AlignmentParams
from spats_shape_seq.mask import Mask, match_mask_optimized, base_similarity_ind
target_seq = "GGACCCGATGCCGGACGAAAGTCCGCGCATCAACTATGCCTCTACCTGCTTCGGCCGATAAAGCCGACGATAATACTCCCAAAGCCC" # HairpinC_SS2
r1_seq = "GGGTGAGCGTGCTTTGGGAGTATTATCGTCGGCTTTATCGGCCGAAGCAGGTAGTGCATAGTTGATGCTCGGACTTTCG"
r2_seq = "GGACCCGATGCCGGACGAAAGTCCGAGCATCAACTATGCCCTACCTGCTTCGGCCGATAAAGCCAAAAGACGATAAT"
pair = Pair()
pair.set_from_data("TEST_PAIR", r1_seq, r2_seq)
targets = Targets()
targets.minimum_match_length = 10
targets.addTarget("TEST_TARGET", target_seq, 0)
targets.index()
mask = match_mask_optimized(pair.r1.original_seq)
assert (mask)
pair.set_mask(Mask(mask))
target = pair.r1.find_in_targets(targets)
pair.target = pair.r2.find_in_targets(targets, force_target=target)
assert (pair.matched)
masklen = pair.mask.length()
adapter_t = "AATGATACGGCGACCACCGAGATCTACACTCTTTCCCTACACGACGCTCTTCCGATCT"
r2suffix = reverse_complement(
pair.r1.original_seq[:masklen]) + reverse_complement(adapter_t)
simfn = lambda nt1, nt2: base_similarity_ind(nt1, nt2, 3, 2, 1.5)
ap = AlignmentParams(simfn, 5, 1)
pair.r2.align_with_target(pair.target, ap, r2suffix)
r2_adapter_trim = max(
0, pair.r2.match_index + pair.r2.match_len - pair.target.n)
r1_adapter_trim = pair.r1.seq_len - (pair.target.n - pair.r2.match_index)
if r1_adapter_trim > 0:
pair.r1.rtrim += r1_adapter_trim
pair.r1.match_start -= r1_adapter_trim
pair.r1.align_with_target(pair.target, ap)
exit(0)
def align_pairs():
from spats_shape_seq.pair import Pair
from spats_shape_seq.target import Targets
from spats_shape_seq.util import reverse_complement, AlignmentParams
from spats_shape_seq.mask import Mask, match_mask_optimized, base_similarity_ind
target_seq = "GGACCCGATGCCGGACGAAAGTCCGCGCATCAACTATGCCTCTACCTGCTTCGGCCGATAAAGCCGACGATAATACTCCCAAAGCCC" # HairpinC_SS2
r1_seq = "GGGTGAGCGTGCTTTGGGAGTATTATCGTCGGCTTTATCGGCCGAAGCAGGTAGTGCATAGTTGATGCTCGGACTTTCG"
r2_seq = "GGACCCGATGCCGGACGAAAGTCCGAGCATCAACTATGCCCTACCTGCTTCGGCCGATAAAGCCAAAAGACGATAAT"
pair = Pair()
pair.set_from_data("TEST_PAIR", r1_seq, r2_seq)
targets = Targets()
targets.minimum_match_length = 10
targets.addTarget("TEST_TARGET", target_seq, 0)
targets.index()
mask = match_mask_optimized(pair.r1.original_seq)
assert(mask)
pair.set_mask(Mask(mask))
target = pair.r1.find_in_targets(targets)
pair.target = pair.r2.find_in_targets(targets, force_target = target)
assert(pair.matched)
masklen = pair.mask.length()
adapter_t = "AATGATACGGCGACCACCGAGATCTACACTCTTTCCCTACACGACGCTCTTCCGATCT"
r2suffix = reverse_complement(pair.r1.original_seq[:masklen]) + reverse_complement(adapter_t)
simfn = lambda nt1, nt2: base_similarity_ind(nt1, nt2, 3, 2, 1.5)
ap = AlignmentParams(simfn, 5, 1)
pair.r2.align_with_target(pair.target, ap, r2suffix)
r2_adapter_trim = max(0, pair.r2.match_index + pair.r2.match_len - pair.target.n)
r1_adapter_trim = pair.r1.seq_len - (pair.target.n - pair.r2.match_index)
if r1_adapter_trim > 0:
pair.r1.rtrim += r1_adapter_trim
pair.r1.match_start -= r1_adapter_trim
pair.r1.align_with_target(pair.target, ap)
exit(0)
def _loadDBAndModel(self):
rsnames = self._db.result_sets()
if rsnames:
self.result_set_id = self._db.result_set_id_for_name(rsnames[0])
self._db.index_results()
self.has_tags = bool(self.result_set_id)
else:
self.result_set_id = -1
self.has_tags = False
self.has_counters = self._db.has_counters()
s = Spats()
self._db.load_run(s.run)
s.run._p_use_tag_processor = True
s.loadTargets(self._db)
if self.has_counters:
self._db.load_counters("spats", s.counters)
if self.has_tags:
p = s._processor
for t in s._targets.targets:
p.addTagTarget(t.name, t.seq)
p.addTagTarget(t.name + "_rc", reverse_complement(t.seq))
self.colors._colors[t.name.lower()] = self.colors.color("target")
p.addTagTarget("adapter_t_rc", reverse_complement(s.run.adapter_t))
p.addTagTarget("adapter_b", s.run.adapter_b)
if s.run.cotrans:
p.addTagTarget("linker_cotrans", s.run.cotrans_linker)
p.addTagTarget("linker_cotrans_rc", reverse_complement(s.run.cotrans_linker))
if s.run._p_extra_tags:
for tag, seq in s.run._p_extra_tags.iteritems():
p.addTagTarget(tag, seq)
if not self.has_counters:
p.counters.load_from_db_data(self._db.counter_data_for_results(self.result_set_id))
self._spats = s
def test_tags():
bp = "/Users/jbrink/mos/tasks/1RwIBa/tmp/5sq_dev/"
from spats_shape_seq import Spats
s = Spats()
from spats_shape_seq.tag import TagProcessor
s.run._processor_class = TagProcessor
#from spats_shape_seq.target import Targets
#s.addTargets(bp + "5S.fa")
s.addTarget("5s", "GGATGCCTGGCGGCCGTAGCGCGGTGGTCCCACCTGACCCCATGCCGAACTCAGAAGTGAAACGCCGTAGCGCCGATGGTAGTGTGGGGTCTCCCCATGCGAGAGTAGGGAACTGCCAGGCATCTGACTCGGGCACCAAGGAC")
#s.addTarget("rc(5s)", "GTCCTTGGTGCCCGAGTCAGATGCCTGGCAGTTCCCTACTCTCGCATGGGGAGACCCCACACTACCATCGGCGCTACGGCGTTTCACTTCTGAGTTCGGCATGGGGTCAGGTGGGACCACCGCGCTACGGCCGCCAGGCATCC")
#s.addTarget("adapter_t", s.run.adapter_t)
#s.addTarget("adapter_b", s.run.adapter_b)
#s._targets._index_word_length = 8
#s._targets._minimum_length = 8
#s.addTarget("adapter_t_rc", reverse_complement(s.run.adapter_t))
#s.addTarget("adapter_b_rc", reverse_complement(s.run.adapter_b))
p = s._processor
p.addTagTarget("5s", "GGATGCCTGGCGGCCGTAGCGCGGTGGTCCCACCTGACCCCATGCCGAACTCAGAAGTGAAACGCCGTAGCGCCGATGGTAGTGTGGGGTCTCCCCATGCGAGAGTAGGGAACTGCCAGGCATCTGACTCGGGCACCAAGGAC")
p.addTagTarget("5s_rc", "GTCCTTGGTGCCCGAGTCAGATGCCTGGCAGTTCCCTACTCTCGCATGGGGAGACCCCACACTACCATCGGCGCTACGGCGTTTCACTTCTGAGTTCGGCATGGGGTCAGGTGGGACCACCGCGCTACGGCCGCCAGGCATCC")
from spats_shape_seq.util import reverse_complement
p.addTagTarget("adapter_t_rc", reverse_complement(s.run.adapter_t))
p.addTagTarget("adapter_b", s.run.adapter_b)
from spats_shape_seq.pair import Pair
cases = [
[ "1101:20069:1063", "TTTAGTCCTTGGTGCCCGAGTCAGATGCCTGGCAG", "TCCCACCTGACCCCATGCCGAACTCAGAAGTGAAA" ],
[ "1101:11562:1050", "AAACGTCCTTGGTGCCCGAGTCAGATGCCTGGCAG", "CCACCTGACCCCATGCCGAACTCAGAAGTGAAACG" ],
[ "21189", "TTTGGTCCTTGGTGCCCGAGTCAGAGATCGGAAGA", "CTGACTCGGGCACCAAGGACCAAAAGATCGGAAGA" ],
[ "1101:12888:8140", "GGATGTCCTTGGTGCCCGAGTCAGATGCCAGATCG", "GGCATCTGACTCGGGCACCAAGGACATACAGATCG" ],
[ "18333", "GAGTGTCCTTGGTGCCCGAGTCAGTGGTAGATCGG", "ACCACTGACTCGGGCACCAAGGACACTCAGATCGG" ],
]
pair = Pair()
for case in cases:
pair.set_from_data(case[0], case[1], case[2])
s.process_pair(pair)
print pair.r1.original_seq
print pair.r1.tags
print pair.r2.original_seq
print pair.r2.tags
print "-----------------------------"
def rc():
from spats_shape_seq.util import reverse_complement
print reverse_complement(sys.argv[2])
def test_reverse_complement(self):
self.assertEqual("GATC", reverse_complement("GATC"))
self.assertEqual("CGTCCAA", reverse_complement("TTGGACG"))
self.assertEqual("CAACAGAGCCCCCGAT", reverse_complement("ATCGGGGGCTCTGTTG"))
self.assertEqual("GATNC", reverse_complement("GNATC"))
def test_tags():
bp = "/Users/jbrink/mos/tasks/1RwIBa/tmp/5sq_dev/"
from spats_shape_seq import Spats
s = Spats()
from spats_shape_seq.tag import TagProcessor
s.run._processor_class = TagProcessor
#from spats_shape_seq.target import Targets
#s.addTargets(bp + "5S.fa")
s.addTarget(
"5s",
"GGATGCCTGGCGGCCGTAGCGCGGTGGTCCCACCTGACCCCATGCCGAACTCAGAAGTGAAACGCCGTAGCGCCGATGGTAGTGTGGGGTCTCCCCATGCGAGAGTAGGGAACTGCCAGGCATCTGACTCGGGCACCAAGGAC"
)
#s.addTarget("rc(5s)", "GTCCTTGGTGCCCGAGTCAGATGCCTGGCAGTTCCCTACTCTCGCATGGGGAGACCCCACACTACCATCGGCGCTACGGCGTTTCACTTCTGAGTTCGGCATGGGGTCAGGTGGGACCACCGCGCTACGGCCGCCAGGCATCC")
#s.addTarget("adapter_t", s.run.adapter_t)
#s.addTarget("adapter_b", s.run.adapter_b)
#s._targets._index_word_length = 8
#s._targets._minimum_length = 8
#s.addTarget("adapter_t_rc", reverse_complement(s.run.adapter_t))
#s.addTarget("adapter_b_rc", reverse_complement(s.run.adapter_b))
p = s._processor
p.addTagTarget(
"5s",
"GGATGCCTGGCGGCCGTAGCGCGGTGGTCCCACCTGACCCCATGCCGAACTCAGAAGTGAAACGCCGTAGCGCCGATGGTAGTGTGGGGTCTCCCCATGCGAGAGTAGGGAACTGCCAGGCATCTGACTCGGGCACCAAGGAC"
)
p.addTagTarget(
"5s_rc",
"GTCCTTGGTGCCCGAGTCAGATGCCTGGCAGTTCCCTACTCTCGCATGGGGAGACCCCACACTACCATCGGCGCTACGGCGTTTCACTTCTGAGTTCGGCATGGGGTCAGGTGGGACCACCGCGCTACGGCCGCCAGGCATCC"
)
from spats_shape_seq.util import reverse_complement
p.addTagTarget("adapter_t_rc", reverse_complement(s.run.adapter_t))
p.addTagTarget("adapter_b", s.run.adapter_b)
from spats_shape_seq.pair import Pair
cases = [
[
"1101:20069:1063", "TTTAGTCCTTGGTGCCCGAGTCAGATGCCTGGCAG",
"TCCCACCTGACCCCATGCCGAACTCAGAAGTGAAA"
],
[
"1101:11562:1050", "AAACGTCCTTGGTGCCCGAGTCAGATGCCTGGCAG",
"CCACCTGACCCCATGCCGAACTCAGAAGTGAAACG"
],
[
"21189", "TTTGGTCCTTGGTGCCCGAGTCAGAGATCGGAAGA",
"CTGACTCGGGCACCAAGGACCAAAAGATCGGAAGA"
],
[
"1101:12888:8140", "GGATGTCCTTGGTGCCCGAGTCAGATGCCAGATCG",
"GGCATCTGACTCGGGCACCAAGGACATACAGATCG"
],
[
"18333", "GAGTGTCCTTGGTGCCCGAGTCAGTGGTAGATCGG",
"ACCACTGACTCGGGCACCAAGGACACTCAGATCGG"
],
]
pair = Pair()
for case in cases:
pair.set_from_data(case[0], case[1], case[2])
s.process_pair(pair)
print pair.r1.original_seq
print pair.r1.tags
print pair.r2.original_seq
print pair.r2.tags
print "-----------------------------"
def rc():
from spats_shape_seq.util import reverse_complement
print reverse_complement(sys.argv[2])
def test_reverse_complement(self):
self.assertEqual("GATC", reverse_complement("GATC"))
self.assertEqual("CGTCCAA", reverse_complement("TTGGACG"))
self.assertEqual("CAACAGAGCCCCCGAT", reverse_complement("ATCGGGGGCTCTGTTG"))
self.assertEqual("GATNC", reverse_complement("GNATC"))
def build(self):
BaseScene.build(self)
processor = self.ui.processor
seqs = {
"adapter_t_rc" : reverse_complement(processor._run.adapter_t),
"adapter_b" : processor._run.adapter_b,
"RRRY" : "RRRY",
"YYYR" : "YYYR",
}
for target in processor._tag_targets.targets:
seqs[target.name] = target.seq
seqs[target.name + "_rc"] = reverse_complement(target.seq)
self.tag_seqs = seqs
colors = self.ui.colors
target = self.pair.target
colors._colors[target.name] = colors.color("target")
tcol = colors.color("target")
nomatch_col = colors.color("grey")
error_col = colors.color("error")
skips = self._skips()
tseq = target.seq
tlen = target.n
def should_skip(idx):
for skip in skips:
if idx >= skip[0] and idx < skip[0] + skip[1]:
return True
return False
self.parts[target.name] = [ None if should_skip(i) else self.addNucView(Nuc(tseq[i], (target.name, i, None)), tcol) for i in range(tlen) ]
self.labels[target.name] = self.addLabel(target.name, bg = tcol)
for part_name in ( "r1", "r2" ):
parts = []
part = getattr(self.pair, part_name)
seq = part.original_seq
idx = 0
for tag in sorted(part.tags, key = lambda t : t[1]):
tkey = tag[0].rstrip("_rc_")
while idx < tag[1] + tag[2]:
ntcol = nomatch_col if idx < tag[1] else colors.color(tkey)
if idx in part.match_errors or idx in part.adapter_errors:
ntcol = error_col
parts.append(self.addNucView(Nuc(seq[idx], (part_name, idx, None if idx < tag[1] else tag[0])), ntcol))
idx += 1
if self.expanded:
if tag[0] == target.name + "_rc":
rc = reverse_complement(seq[tag[1]:tag[1] + tag[2]])
self.parts[part_name + tag[0]] = [ self.addNucView(Nuc(rc[j], (tag[0], j, None)), tcol) for j in range(0, tag[2]) ]
self.labels[part_name + tag[0]] = self.addLabel("R1_rc")
elif tkey.startswith("adapter"):
tagseq = self.tag_seqs[tag[0]]
aparts = []
for j in range(max(tag[3] - 4, 0), min(tag[2] + 4, len(tagseq))):
v = self.addNucView(Nuc(tagseq[j], (tag[0], j, None)), colors.color(tkey))
if j < tag[3] or j >= tag[3] + tag[2]:
v.alpha = 0.5
aparts.append(v)
self.parts[part_name + tag[0]] = aparts
self.labels[part_name + tag[0]] = self.addLabel(tag[0], bg = colors.color(tkey))
elif part_name == "r1" and (tag[0] == 'YYYR' or tag[0] == 'RRRY'):
hcol = colors.color(tag[0])
self.parts[part_name + tag[0]] = [ self.addNucView(Nuc(tag[0][j], (tag[0], j, None)), hcol) for j in range(len(tag[0])) ]
self.labels[part_name + tag[0]] = self.addLabel(tag[0], bg = hcol)
while idx < len(seq):
parts.append(self.addNucView(Nuc(seq[idx], (part_name, idx, None)), nomatch_col))
idx += 1
self.parts[part_name] = parts
self.labels[part_name] = self.addLabel(part_name.upper())