def test_map(self):
"""reversing a map with multiple spans should preserve span relative
order"""
forward = [Span(20, 30), Span(40, 50)]
fmap = Map(spans=forward, parent_length=100)
fmap_reversed = fmap.nucleicReversed()
reverse = [Span(70, 80, Reverse=True), Span(50, 60, Reverse=True)]
rmap = Map(spans=reverse, parent_length=100)
for i in range(2):
self.assertEquals(fmap_reversed.spans[i], rmap.spans[i])
def test_get_coords(self):
"""getCoordinates should return raw coordinates matching input"""
spans = [(0, 9), (20, 32)]
map = Map(spans, parent_length=100)
coords = map.getCoordinates()
self.assertEqual(coords, spans)
# should work for reversed Maps too
spans = [(32, 20), (9, 0)]
map = Map(spans, parent_length=100)
coords = map.getCoordinates()
self.assertEqual(coords, spans)
def __init__(self, base, policy=DisplayPolicy, _policy=None, pad=1,
yrange=None, **kw):
self.pad = pad
self.base = base
self.yrange = yrange
assert len(base) > 0, len(base)
if _policy is None:
policy = policy(**kw).copy(
map=Map([(0, len(base))], parent_length=len(base)),
depth=0,
rowlen=len(base))
else:
policy = _policy
self.policy = policy
self.smap=Map([(0, len(base))], parent_length=len(base))
self._calc_tracks()
def _remap(map):
start = map.Start
if start == 0:
new_map = map
new_map.parent_length = map.End
else:
spans = []
for span in map.spans:
if span.lost:
spans.append(span)
else:
span.Start = span.Start - start
span.End = span.End - start
length = span.End
spans.append(span)
new_map = Map(spans=spans, parent_length=length)
return new_map
def cigar_to_map(cigar_text):
"""convert cigar string into Map"""
assert 'I' not in cigar_text
spans, posn = [], 0
for n, c in pattern.findall(cigar_text):
if n:
n = int(n)
else:
n = 1
if c == 'M':
spans.append(Span(posn, posn + n))
posn += n
else:
spans.append(LostSpan(n))
map = Map(spans=spans, parent_length=posn)
return map
def test_spans(self):
# a simple two part map of length 10
map = Map([(0, 5), (5, 10)], parent_length=10)
# try different spans on the above map
for ((start, end), expected) in [
((0, 4), "[0:4]"),
((0, 5), "[0:5]"),
((0, 6), "[0:5, 5:6]"),
((5, 10), "[5:10]"),
((-1, 10), "[-1-, 0:5, 5:10]"),
((5, 11), "[5:10, -1-]"),
((0, 10), "[0:5, 5:10]"),
((10, 0), "[10:5, 5:0]"),
]:
r = repr(Span(start, end, Reverse=start > end).remapWith(map))
#print (start, end), r,
if r != expected:
self.fail(repr((r, expected)))
sliced_seq.getByAnnotation('test_type', ignore_partial=True))
self.assertEqual(len(answer), 1)
self.assertEqual(str(answer[0]), 'TCGAT')
def test_getBySequenceAnnotation(self):
aln = LoadSeqs(data={'a': 'ATCGAAATCGAT', 'b': 'ATCGA--TCGAT'})
b = aln.getSeq('b')
b.addAnnotation(Feature, 'test_type', 'test_label', [(4, 6)])
answer = aln.getBySequenceAnnotation('b', 'test_type')[0].todict()
self.assertEqual(answer, {'b': 'A--T', 'a': 'AAAT'})
if 0: # old, needs fixes
# Maps
a = Map([(10, 20)], parent_length=100)
for (desc, map, expected) in [
('a ', a, "Map([10:20] on base)"),
('i ', a.inverse(), "Map([-10-, 0:10, -80-] on Map([10:20] on base))"),
('1 ', a[5:], "Map([5:10] on Map([10:20] on base))"),
('1r', a[5:].relative_to(b), "Map([15:20] on base)"),
('2 ', a[:5], "Map([0:5] on Map([10:20] on base))"),
('2r', a[:5].relative_to(b), "Map([10:15] on base)"),
('r ', a.relative_to(a[5:]),
"Map([-5-, 0:5] on Map([5:10] on Map([10:20] on base)))"),
('r ', a[2:4].relative_to(a[2:6]),
"Map([0:2] on Map([2:6] on Map([10:20] on base)))"),
('r ', a[2:4].relative_to(a[2:6][0:3]),
"Map([0:2] on Map([0:3] on Map([2:6] on Map([10:20] on base))))")
]:
