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)
