def test_equal(): range_a = intrange(1, 5) range_b = intrange(10, 15) assert intrangeset([range_a, range_b]) == intrangeset([range_a, range_b]) assert not intrangeset([range_a, range_b]) == intrangeset([range_a]) assert not intrangeset([range_a]) == "foo"
def test_equal(): range_a = intrange(1, 5) range_b = intrange(10, 15) assert intrangeset([range_a, range_b]) == intrangeset([range_a, range_b]) assert not intrangeset([range_a, range_b]) == intrangeset([range_a]) assert not intrangeset([range_a]) == "foo"
def test_last(): assert intrange().last is None assert intrange.empty().last is None assert intrange(1).last is None assert intrange(upper=10).last == 9 assert intrange(1, 10).last == 9
def test_greater_than(): range_a = intrange(1, 5) range_b = intrange(10, 15) assert intrangeset([range_a, range_b]) > intrangeset([range_a]) assert not intrangeset([range_a, range_b]) > intrangeset([range_b]) assert intrangeset([range_b]) > intrangeset([range_a, range_b]) assert intrangeset([range_a, range_b]) >= intrangeset([range_a])
def test_add(): rset = intrangeset([intrange(1, 15)]) rset.add(intrange(5, 15)) assert list(rset) == [intrange(1, 15)] with pytest.raises(TypeError): rset.add(floatrange(1.0))
def test_less_than(): range_a = intrange(1, 5) range_b = intrange(10, 15) assert not intrangeset([range_a, range_b]) < intrangeset([range_a]) assert intrangeset([range_a, range_b]) < intrangeset([range_b]) assert not intrangeset([range_a, range_b]) <= intrangeset([range_a]) assert not intrangeset([range_a]) == "foo"
def test_greater_than(): range_a = intrange(1, 5) range_b = intrange(10, 15) assert intrangeset([range_a, range_b]) > intrangeset([range_a]) assert not intrangeset([range_a, range_b]) > intrangeset([range_b]) assert intrangeset([range_b]) > intrangeset([range_a, range_b]) assert intrangeset([range_a, range_b]) >= intrangeset([range_a])
def test_add(): rset = intrangeset([intrange(1, 15)]) rset.add(intrange(5, 15)) assert list(rset) == [intrange(1, 15)] with pytest.raises(TypeError): rset.add(floatrange(1.0))
def test_less_than(): range_a = intrange(1, 5) range_b = intrange(10, 15) assert not intrangeset([range_a, range_b]) < intrangeset([range_a]) assert intrangeset([range_a, range_b]) < intrangeset([range_b]) assert not intrangeset([range_a, range_b]) <= intrangeset([range_a]) assert not intrangeset([range_a]) == "foo"
def test_offset(): low_range = intrange(0, 5) high_range = intrange(5, 10) assert low_range != high_range assert low_range.offset(5) == high_range assert low_range == high_range.offset(-5) with pytest.raises(TypeError): low_range.offset(5.0)
def parse(cls, utterance: str, vocabs: dict, named_entity: NamedEntity): original = utterance utterance = utterance.lower() items = [] while True: m = cls.__slot_pattern.search(utterance) if not m: break text = m.group(1) label = m.group(2) start = m.start() end = start + len(text) items.append({ 'text': text, 'label': label, 'span': intrange(start, end) }) utterance = utterance.replace(m.group(0), text, 1) tokens = [] labels = [] for token in pyokt.tokenize(utterance): if token.text.isspace(): continue span = intrange(token.offset, token.offset + token.length) tokens.append({ 'text': token.text, 'span': span }) found = False for item in items: if item['span'].contains(span): label = ('b-' if item['span'].lower == span.lower else 'i-') + item['label'] labels.append(label) found = True break if not found: labels.append('o') encoded_tokens = [vocabs['text'].transform(token['text']) for token in tokens] encoded_labels = [vocabs['label'].transform(label) for label in labels] entities = named_entity.recognize(tokens) encoded_entities = [ [vocabs['named_entity'].transform(unit) for unit in entity] for entity in entities ] return Utterance( original, utterance, tokens, encoded_tokens, encoded_entities, encoded_labels )
def test_default_bounds(): inf_range = intrange() assert not inf_range.lower_inc assert not inf_range.upper_inc bounded_range = intrange(1, 10) assert bounded_range.lower_inc assert not bounded_range.upper_inc rebound_range = intrange().replace(lower=1, upper=10) assert rebound_range.lower_inc assert not rebound_range.upper_inc
def test_bug3_intersection(): """ `Bug #3 <https://github.com/runfalk/spans/issues/3>`_ """ range_a = intrange(1, 5) range_b = intrange(5, 10) range_c = intrange(10, 15) rangeset_a = intrangeset([range_a, range_c]) rangeset_b = intrangeset([range_b]) rangeset_c = intrangeset([range_c]) rangeset_empty = intrangeset([]) assert rangeset_a.intersection(rangeset_b, rangeset_c) == rangeset_empty
def test_bug3_intersection(): """ `Bug #3 <https://github.com/runfalk/spans/issues/3>`_ """ range_a = intrange(1, 5) range_b = intrange(5, 10) range_c = intrange(10, 15) rangeset_a = intrangeset([range_a, range_c]) rangeset_b = intrangeset([range_b]) rangeset_c = intrangeset([range_c]) rangeset_empty = intrangeset([]) assert rangeset_a.intersection(rangeset_b, rangeset_c) == rangeset_empty
def test_difference_typecheck(): a = floatrange(1.0, 10.0) b = intrange(5, 10) with pytest.raises(TypeError): a.difference(b) assert a.__sub__(b) is NotImplemented
def test_intersection_typecheck(): a = floatrange(1.0, 5.0) b = intrange(5, 10) with pytest.raises(TypeError): a.intersection(b) assert a.__and__(b) is NotImplemented
def test_intersection(): a = intrangeset([intrange(1, 5), intrange(20, 30)]) b = intrangeset([intrange(5, 10), intrange(20, 100)]) intersection = [intrange(20, 30)] assert list(a.intersection(b)) == intersection assert list(a & b) == intersection assert not intrangeset([intrange(1, 5)]).intersection( intrangeset([intrange(5, 10)])) with pytest.raises(TypeError): intrangeset([]).intersection(intrange()) assert intrangeset([]).__and__(intrange()) is NotImplemented
def test_intersection(): a = intrangeset([intrange(1, 5), intrange(20, 30)]) b = intrangeset([intrange(5, 10), intrange(20, 100)]) intersection = [intrange(20, 30)] assert list(a.intersection(b)) == intersection assert list(a & b) == intersection assert not intrangeset([intrange(1, 5)]).intersection( intrangeset([intrange(5, 10)])) with pytest.raises(TypeError): intrangeset([]).intersection(intrange()) assert intrangeset([]).__and__(intrange()) is NotImplemented
def test_unbounded(): range = intrange() assert range.lower is None assert range.upper is None assert range.lower_inf assert range.upper_inf
def test_union(): a = intrangeset([intrange(1, 5), intrange(20, 30)]) b = intrangeset([intrange(5, 10), intrange(20, 100)]) union = [intrange(1, 10), intrange(20, 100)] assert list(a.union(b)) == union assert list(a | b) == union with pytest.raises(TypeError): intrangeset([]).union(intrange()) assert intrangeset([]).__or__(intrange()) is NotImplemented
def test_union(): a = intrangeset([intrange(1, 5), intrange(20, 30)]) b = intrangeset([intrange(5, 10), intrange(20, 100)]) union = [intrange(1, 10), intrange(20, 100)] assert list(a.union(b)) == union assert list(a | b) == union with pytest.raises(TypeError): intrangeset([]).union(intrange()) assert intrangeset([]).__or__(intrange()) is NotImplemented
def test_difference(): a = intrangeset([intrange(1, 5), intrange(20, 30)]) b = intrangeset([intrange(5, 10), intrange(20, 100)]) difference = [intrange(1, 5)] assert list(a.difference(b)) == difference assert list(a - b) == difference with pytest.raises(TypeError): intrangeset([]).difference(intrange()) assert intrangeset([]).__sub__(intrange()) is NotImplemented
def test_difference(): a = intrangeset([intrange(1, 5), intrange(20, 30)]) b = intrangeset([intrange(5, 10), intrange(20, 100)]) difference = [intrange(1, 5)] assert list(a.difference(b)) == difference assert list(a - b) == difference with pytest.raises(TypeError): intrangeset([]).difference(intrange()) assert intrangeset([]).__sub__(intrange()) is NotImplemented
def test_immutable(): range = intrange() with pytest.raises(AttributeError): range.lower = 1 with pytest.raises(AttributeError): range.upper = 10 with pytest.raises(AttributeError): range.lower_inc = True with pytest.raises(AttributeError): range.upper_inc = True
def test_remove(): rset = intrangeset([intrange(upper=1), intrange(5)]) rset.remove(intrange(10, 15)) assert rset == intrangeset([intrange(upper=1), intrange(5, 10), intrange(15)]) # Test deletion of empty set temp = rset.copy() temp.remove(intrange.empty()) assert rset == temp # Test total deletion rset.remove(intrange()) assert rset == intrangeset([]) # Test deletion on empty set temp = intrangeset([]) temp.remove(intrange(1, 5)) assert temp == intrangeset([]) with pytest.raises(TypeError): rset.remove(floatrange(1.0))
def test_remove(): rset = intrangeset([intrange(upper=1), intrange(5)]) rset.remove(intrange(10, 15)) assert rset == intrangeset( [intrange(upper=1), intrange(5, 10), intrange(15)]) # Test deletion of empty set temp = rset.copy() temp.remove(intrange.empty()) assert rset == temp # Test total deletion rset.remove(intrange()) assert rset == intrangeset([]) # Test deletion on empty set temp = intrangeset([]) temp.remove(intrange(1, 5)) assert temp == intrangeset([]) with pytest.raises(TypeError): rset.remove(floatrange(1.0))
def intervals_for_chrom(islands_chrom_df, chrom_len): shore_limit = 2000 shelf_limit = shore_limit + 2000 chrom_interval = spans.intrange(0, chrom_len) intervals = { SEA_KEY: spans.intrangeset([chrom_interval]), SHELF_KEY: spans.intrangeset([]), SHORE_KEY: spans.intrangeset([]), ISLAND_KEY: spans.intrangeset([]) } for _, island in islands_chrom_df.iterrows(): add_to_interval(intervals[ISLAND_KEY], island[START_KEY], island[STOP_KEY], 0, chrom_interval) add_to_interval(intervals[SHORE_KEY], island[START_KEY], island[STOP_KEY], shore_limit, chrom_interval) add_to_interval(intervals[SHELF_KEY], island[START_KEY], island[STOP_KEY], shelf_limit, chrom_interval) intervals[SEA_KEY] = intervals[SEA_KEY].difference(intervals[SHELF_KEY]) intervals[SHELF_KEY] = intervals[SHELF_KEY].difference( intervals[SHORE_KEY]) intervals[SHORE_KEY] = intervals[SHORE_KEY].difference( intervals[ISLAND_KEY]) return intervals
def test_non_empty(): assert intrangeset([intrange(1, 5)])
def test_not_contains(value): assert not intrangeset([intrange(1, 10)]).contains(value)
def test_iteration(): ranges = [intrange(1, 5), intrange(10, 15)] assert list(intrangeset(ranges)) == ranges
def test_last(): assert intrange(1).last is None
def test_invert(): rset = intrangeset([intrange(1, 5), intrange(10, 15)]) rset_inv = intrangeset([intrange(upper=1), intrange(5, 10), intrange(15)]) assert ~rset == rset_inv assert rset == ~~rset
def test_equality(): assert intrange(1, 5) == intrange(1, 5) assert intrange.empty() == intrange.empty() assert intrange(1, 5) != intrange(1, 5, upper_inc=True) assert not intrange() == None
def test_offset_unbounded(): range = intrange() assert range == range.offset(10) assert intrange(1).offset(9) == intrange(10) assert intrange(upper=1).offset(9) == intrange(upper=10)
def test_iteration(): ranges = [intrange(1, 5), intrange(10, 15)] assert list(intrangeset(ranges)) == ranges
def test_copy(): rset = intrangeset([intrange(1, 5), intrange(10, 15)]) rcopy = rset.copy() assert list(rset) == list(rcopy) assert rset._list is not rcopy._list
def test_not_contains(value): assert not intrangeset([intrange(1, 10)]).contains(value)
def test_no_lower_bound_iter(): with pytest.raises(TypeError): next(iter(intrange(upper=1)))
def test_values(): values = intrangeset([intrange(1, 5), intrange(10, 15)]).values() assert list(values) == list(range(1, 5)) + list(range(10, 15))
def test_len(): assert len(intrange(0, 5)) == 5
def test_pickling(): span = intrangeset([intrange(1, 10), intrange(20, 30)]) assert span == pickle.loads(pickle.dumps(span))
from spans import \ daterangeset, datetimerangeset, floatrange, floatrangeset, intrange, \ intrangeset, strrangeset, timedeltarangeset def test_empty(): assert not intrangeset([]) def test_non_empty(): assert intrangeset([intrange(1, 5)]) @pytest.mark.parametrize("rangeset, span", [ (intrangeset([intrange(1, 5), intrange(10, 15)]), intrange(1, 15)), (intrangeset([]), intrange.empty()), ]) def test_span(rangeset, span): assert rangeset.span() == span def test_iteration(): ranges = [intrange(1, 5), intrange(10, 15)] assert list(intrangeset(ranges)) == ranges def test_copy(): rset = intrangeset([intrange(1, 5), intrange(10, 15)]) rcopy = rset.copy()
from spans import \ daterangeset, datetimerangeset, floatrange, floatrangeset, intrange, \ intrangeset, strrangeset, timedeltarangeset def test_empty(): assert not intrangeset([]) def test_non_empty(): assert intrangeset([intrange(1, 5)]) @pytest.mark.parametrize("rangeset, span", [ (intrangeset([intrange(1, 5), intrange(10, 15)]), intrange(1, 15)), (intrangeset([]), intrange.empty()), ]) def test_span(rangeset, span): assert rangeset.span() == span def test_iteration(): ranges = [intrange(1, 5), intrange(10, 15)] assert list(intrangeset(ranges)) == ranges def test_copy(): rset = intrangeset([intrange(1, 5), intrange(10, 15)]) rcopy = rset.copy()
def test_invert(): rset = intrangeset([intrange(1, 5), intrange(10, 15)]) rset_inv = intrangeset([intrange(upper=1), intrange(5, 10), intrange(15)]) assert ~rset == rset_inv assert rset == ~~rset
def test_no_lower_upper_reversed(): with pytest.raises(TypeError): next(reversed(intrange(1)))
def test_pickling(): span = intrangeset([intrange(1, 10), intrange(20, 30)]) assert span == pickle.loads(pickle.dumps(span))
def test_copy(): rset = intrangeset([intrange(1, 5), intrange(10, 15)]) rcopy = rset.copy() assert list(rset) == list(rcopy) assert rset._list is not rcopy._list
def test_non_empty(): assert intrangeset([intrange(1, 5)])
def test_reversed(): assert list(reversed(intrange(0, 5))) == list(reversed(range(5))) infinite_iter = reversed(intrange(upper=100)) for i in reversed(range(100)): assert i == next(infinite_iter)
def test_values(): values = intrangeset([intrange(1, 5), intrange(10, 15)]).values() assert list(values) == list(range(1, 5)) + list(range(10, 15))
def add_to_interval(interval, start, stop, dilation, chrom_borders): interval.add( spans.intrange(start - dilation, stop + dilation).intersection(chrom_borders))
import pytest from spans import intrange @pytest.mark.parametrize("a, offset, b", [ (intrange(0), 5, intrange(5)), (intrange(upper=0), 5, intrange(upper=5)), (intrange(0, 5), 5, intrange(5, 10)), (intrange(), 5, intrange()), ]) def test_offset(a, offset, b): assert a.offset(offset) == b
def test_len(): assert len(intrange(0, 5)) == 5
def test_iter(): assert list(intrange(0, 5)) == list(range(5)) infinite_iter = iter(intrange(0)) for i in range(100): assert i == next(infinite_iter)