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)