def test_keysvalues_empty():
sl = SortedList([])
assert(sl._k == [])
assert(sl._k == [])
with pytest.raises(ValueError):
sl.index(0)
def test_keysvalues_empty():
sl = SortedList([])
assert (sl._k == [])
assert (sl._k == [])
with pytest.raises(ValueError):
sl.index(0)
def __init__(self, name, tokens):
self.name = name
self.tokens = SortedList(tokens, key=cmp_to_key(token_cmp))
if len(self.tokens) == 0:
self.interval = None
else:
self.interval = Interval(self.tokens[0].interval.start,
self.tokens[-1].interval.end)
if not all(t1.interval.end == t2.interval.start
for t1, t2 in zip(self.tokens[:-1], self.tokens[1:])):
raise ValueError('Non-contiguous tokens.')
def test_stringlist2(l):
el = l[:-1]
e = l[-1]
sl = SortedList(el)
assert(sorted(el) == sl._v)
assert(sorted(el) == sl._k)
sl.insert(e)
assert(sorted(l) == sl._v)
assert(sorted(l) == sl._k)
sl.remove(e)
assert(sorted(el) == sl._v)
assert(sorted(el) == sl._k)
def test_indexfind_lt():
sl = SortedList([3, 6, 1, 7, 0])
assert (sl.index_lt(3) == 1)
assert (sl.find_lt(3) == 1)
with pytest.raises(ValueError):
sl.index_lt(0)
with pytest.raises(ValueError):
sl.find_lt(0)
def test_indexfind_ge():
sl = SortedList([3, 6, 1, 7, 0])
assert (sl.index_ge(3) == 2)
assert (sl.find_ge(4) == 6)
with pytest.raises(ValueError):
sl.index_ge(10)
with pytest.raises(ValueError):
sl.find_ge(10)
def test_indexfind_gt():
sl = SortedList([3, 6, 1, 7, 0])
assert (sl.index_gt(3) == 3)
assert (sl.find_gt(3) == 6)
with pytest.raises(ValueError):
sl.index_gt(7)
with pytest.raises(ValueError):
sl.find_gt(7)
def test_indexfind_gt():
sl = SortedList([3, 6, 1, 7, 0])
assert(sl.index_gt(3) == 3)
assert(sl.find_gt(3) == 6)
with pytest.raises(ValueError):
sl.index_gt(7)
with pytest.raises(ValueError):
sl.find_gt(7)
def test_indexfind_ge():
sl = SortedList([3, 6, 1, 7, 0])
assert(sl.index_ge(3) == 2)
assert(sl.find_ge(4) == 6)
with pytest.raises(ValueError):
sl.index_ge(10)
with pytest.raises(ValueError):
sl.find_ge(10)
def test_indexfind_lt():
sl = SortedList([3, 6, 1, 7, 0])
assert(sl.index_lt(3) == 1)
assert(sl.find_lt(3) == 1)
with pytest.raises(ValueError):
sl.index_lt(0)
with pytest.raises(ValueError):
sl.find_lt(0)
def test_tuplelist():
data = [(3, 'a'), (4, 'v'), (1, 'z'), (5, 'b')]
sl = SortedList(data, key=lambda x: x[1])
assert (sl._k == ['a', 'b', 'v', 'z'])
assert (sl._v == [(3, 'a'), (5, 'b'), (4, 'v'), (1, 'z')])
assert (sl.index_lt((10, 'e')) == 1)
assert (sl.index_le((10, 'e')) == 1)
assert (sl.index_lt((5, 'b')) == 0)
with pytest.raises(ValueError):
sl.index((10, 'b'))
with pytest.raises(ValueError):
sl.index((3, 'b'))
def __init__(self, name, tokens):
self.name = name
self.tokens = SortedList(tokens, key=cmp_to_key(token_cmp))
if len(self.tokens) == 0:
self.interval = None
else:
self.interval = Interval(self.tokens[0].interval.start,
self.tokens[-1].interval.end)
if not all(t1.interval.end == t2.interval.start
for t1, t2 in zip(self.tokens[:-1], self.tokens[1:])):
raise ValueError('Non-contiguous tokens.')
def __init__(self, segment_annotations=None):
self.segment_annotations = {}
if segment_annotations is None:
segment_annotations = []
for fa in segment_annotations:
try:
self.segment_annotations[fa.name].insert(fa)
except KeyError:
self.segment_annotations[fa.name] = \
SortedList([fa], key=cmp_to_key(annotation_cmp))
self._cache = {}
def test_tuplelist_random(l1, l2):
zip1 = zip(l1, l2)
l1 = l1[:len(zip1)]
l2 = l2[:len(zip1)]
sl = SortedList(zip1, key=lambda x: x[0])
assert (sorted(l1) == sl._k)
assert (sorted(zip1, key=lambda x: (x[0], x[1])) == sl._v)
sl = SortedList(zip1, key=lambda x: x[1])
assert (sorted(l2) == sl._k)
assert (sorted(zip1, key=lambda x: (x[1], x[0])) == sl._v)
zip2 = zip(l2, l1)
sl = SortedList(zip2, key=lambda x: x[0])
assert (sorted(l2) == sl._k)
assert (sorted(zip2, key=lambda x: x[0]) == sl._v)
sl = SortedList(zip2, key=lambda x: x[1])
assert (sorted(l1) == sl._k)
assert (sorted(zip2, key=lambda x: x[1]) == sl._v)
def test_tuplelist():
data = [(3, 'a'), (4, 'v'), (1, 'z'), (5, 'b')]
sl = SortedList(data, key=lambda x: x[1])
assert(sl._k == ['a', 'b', 'v', 'z'])
assert(sl._v == [(3, 'a'), (5, 'b'), (4, 'v'), (1, 'z')])
assert(sl.index_lt((10, 'e')) == 1)
assert(sl.index_le((10, 'e')) == 1)
assert(sl.index_lt((5, 'b')) == 0)
with pytest.raises(ValueError):
sl.index((10, 'b'))
with pytest.raises(ValueError):
sl.index((3, 'b'))
def test_stringlist2(l):
el = l[:-1]
e = l[-1]
sl = SortedList(el)
assert (sorted(el) == sl._v)
assert (sorted(el) == sl._k)
sl.insert(e)
assert (sorted(l) == sl._v)
assert (sorted(l) == sl._k)
sl.remove(e)
assert (sorted(el) == sl._v)
assert (sorted(el) == sl._k)
def test_insert():
sl = SortedList([3, 6, 1, 7, 0])
sl.insert(4)
assert (sl._k == [0, 1, 3, 4, 6, 7])
assert (sl._v == [0, 1, 3, 4, 6, 7])
def test_badremove():
sl = SortedList([3, 6, 1, 7, 0])
with pytest.raises(ValueError):
sl.remove(4)
def test_badindex():
sl = SortedList([3, 6, 1, 7, 0])
with pytest.raises(ValueError):
sl.index(4)
def test_contains():
sl = SortedList([3, 6, 1, 7, 0])
for item in sl:
assert (item in sl)
class SegmentAnnotation(collections.Sequence):
"""
Annotation for contiguous time segment.
This class represents a contiguous sequence of annotations. It contains
methods for efficiently finding the annotation corresponding to a temporal
interval.
Parameters
----------
name : string
Identifier for the annotation.
tokens : list of Fragment objects
The sequence of annotations.
Attributes
----------
interval : Interval
The temporal interval that is covered.
Raises
------
ValueError
If tokens are not contiguous or don't all have the same name.
"""
def __init__(self, name, tokens):
self.name = name
self.tokens = SortedList(tokens, key=cmp_to_key(token_cmp))
if len(self.tokens) == 0:
self.interval = None
else:
self.interval = Interval(self.tokens[0].interval.start,
self.tokens[-1].interval.end)
if not all(t1.interval.end == t2.interval.start
for t1, t2 in zip(self.tokens[:-1], self.tokens[1:])):
raise ValueError('Non-contiguous tokens.')
def __len__(self):
return len(self.tokens)
def __iter__(self):
return iter(self.tokens)
def __getitem__(self, i):
return self.tokens[i]
def __repr__(self):
return '%s(%r)' % (self.__class__.__name__, self.__dict__)
def __str__(self):
return '<SegmentAnnotation {0} {1} {2} tokens>'.format(
self.name, str(self.interval), len(self.tokens))
def __eq__(self, other):
if self.name != other.name:
return False
if self.interval != other.interval:
return False
if len(self.tokens) != len(other.tokens):
return False
return all(t1 == t2 for t1, t2 in zip(self.tokens, other.tokens))
def __ne__(self, other):
return not self.__eq__(other)
def restrict(self, interval_db):
"""
Restrict the SegmentAnnotation to a set of Intervals.
Returns a new SegmentAnnotation object with only the FragmentTokens
that are fully covered in `interval_db`.
Parameters
----------
interval_db : IntervalDB
Returns
-------
SegmentAnnotation
New SegmentAnnotation object.
"""
return SegmentAnnotation(self.name,
[f for f in self.tokens
if interval_db.is_covered(f.name, f.interval)])
def annotation_at_interval(self, interval):
"""
Get the annotation corresponding to an interval.
Parameters
----------
interval : Interval
Returns
-------
s : list of strings
Annotation symbols covered by the interval.
"""
return tuple([x.mark for x in self.tokens_at_interval(interval)])
def tokens_at_interval(self, interval):
"""
Get the annotation tokens corresponding to an interval.
Parameters
----------
interval : Interval
Returns
-------
tuple of FragmentTokens
FragmentTokens covered by the interval.
"""
if len(self.tokens) > 0:
name = self.tokens[0].name
else:
return tuple()
dummy_token = FragmentToken(name, interval, None)
try:
start = self.tokens.index_ge(dummy_token)
except ValueError:
return tuple()
try:
stop = self.tokens.index_gt(dummy_token)
except ValueError:
stop = len(self.tokens)
return tuple([x for x in self.tokens[start:stop]])
class SegmentAnnotation(collections.Sequence):
"""
Annotation for contiguous time segment.
This class represents a contiguous sequence of annotations. It contains
methods for efficiently finding the annotation corresponding to a temporal
interval.
Parameters
----------
name : string
Identifier for the annotation.
tokens : list of Fragment objects
The sequence of annotations.
Attributes
----------
interval : Interval
The temporal interval that is covered.
Raises
------
ValueError
If tokens are not contiguous or don't all have the same name.
"""
def __init__(self, name, tokens):
self.name = name
self.tokens = SortedList(tokens, key=cmp_to_key(token_cmp))
if len(self.tokens) == 0:
self.interval = None
else:
self.interval = Interval(self.tokens[0].interval.start,
self.tokens[-1].interval.end)
if not all(t1.interval.end == t2.interval.start
for t1, t2 in zip(self.tokens[:-1], self.tokens[1:])):
# raise ValueError('Non-contiguous tokens.')
pass
def __len__(self):
return len(self.tokens)
def __iter__(self):
return iter(self.tokens)
def __getitem__(self, i):
return self.tokens[i]
def __repr__(self):
return '%s(%r)' % (self.__class__.__name__, self.__dict__)
def __str__(self):
return '<SegmentAnnotation {0} {1} {2} tokens>'.format(
self.name, str(self.interval), len(self.tokens))
def __eq__(self, other):
if self.name != other.name:
return False
if self.interval != other.interval:
return False
if len(self.tokens) != len(other.tokens):
return False
return all(t1 == t2 for t1, t2 in zip(self.tokens, other.tokens))
def __ne__(self, other):
return not self.__eq__(other)
def restrict(self, interval_db):
"""
Restrict the SegmentAnnotation to a set of Intervals.
Returns a new SegmentAnnotation object with only the FragmentTokens
that are fully covered in `interval_db`.
Parameters
----------
interval_db : IntervalDB
Returns
-------
SegmentAnnotation
New SegmentAnnotation object.
"""
return SegmentAnnotation(self.name,
[f for f in self.tokens
if interval_db.is_covered(f.name, f.interval)])
def annotation_at_interval(self, interval):
"""
Get the annotation corresponding to an interval.
Parameters
----------
interval : Interval
Returns
-------
s : list of strings
Annotation symbols covered by the interval.
"""
return tuple([x.mark for x in self.tokens_at_interval(interval)])
def tokens_at_interval(self, interval):
"""
Get the annotation tokens corresponding to an interval.
Parameters
----------
interval : Interval
Returns
-------
tuple of FragmentTokens
FragmentTokens covered by the interval.
"""
if len(self.tokens) > 0:
name = self.tokens[0].name
else:
return tuple()
dummy_token = FragmentToken(name, interval, None)
try:
start = self.tokens.index_ge(dummy_token)
except ValueError:
return tuple()
try:
stop = self.tokens.index_gt(dummy_token)
except ValueError:
stop = len(self.tokens)
return tuple([x for x in self.tokens[start:stop]])
def test_str_repr():
sl = SortedList([3, 6, 1, 7, 0])
assert (repr(sl) == '[0, 1, 3, 6, 7]')
assert (str(sl) == '[0, 1, 3, 6, 7]')
def test_floatlist1(l):
sl = SortedList(l)
assert (sorted(l) == sl._v)
assert (sorted(l) == sl._k)
def test_insert_duplicate():
sl = SortedList([3, 6, 1, 7, 0])
sl.insert(3)
assert(sl._k == [0, 1, 3, 3, 6, 7])
assert(sl._v == [0, 1, 3, 3, 6, 7])
def test_getitem():
sl = SortedList([3, 6, 1, 7, 0])
for ix, item in enumerate(sl):
assert (item == sl[ix])
def test_extend():
sl = SortedList([3, 6, 1, 7, 0])
sl.extend([4, 5])
assert(sl._k == [0, 1, 3, 4, 5, 6, 7])
assert(sl._v == [0, 1, 3, 4, 5, 6, 7])
def test_insert_duplicate():
sl = SortedList([3, 6, 1, 7, 0])
sl.insert(3)
assert (sl._k == [0, 1, 3, 3, 6, 7])
assert (sl._v == [0, 1, 3, 3, 6, 7])
def test_extend():
sl = SortedList([3, 6, 1, 7, 0])
sl.extend([4, 5])
assert (sl._k == [0, 1, 3, 4, 5, 6, 7])
assert (sl._v == [0, 1, 3, 4, 5, 6, 7])
def test_insert():
sl = SortedList([3, 6, 1, 7, 0])
sl.insert(4)
assert(sl._k == [0, 1, 3, 4, 6, 7])
assert(sl._v == [0, 1, 3, 4, 6, 7])
def test_len():
sl = SortedList([3, 6, 1, 7, 0])
assert (len(sl) == 5)
sl.insert(4)
assert (len(sl) == 6)
def test_badremove():
sl = SortedList([3, 6, 1, 7, 0])
with pytest.raises(ValueError):
sl.remove(4)
def test_keysvalues():
sl = SortedList([3, 6, 1, 7, 0])
assert (sl._k == [0, 1, 3, 6, 7])
assert (sl._v == [0, 1, 3, 6, 7])
def test_badindex():
sl = SortedList([3, 6, 1, 7, 0])
with pytest.raises(ValueError):
sl.index(4)
def test_stringlist1(l):
sl = SortedList(l)
assert (sorted(l) == sl._v)
assert (sorted(l) == sl._k)
def test_len():
sl = SortedList([3, 6, 1, 7, 0])
assert(len(sl) == 5)
sl.insert(4)
assert(len(sl) == 6)
