def test_intervaldict_iterators():
d = I.IntervalDict([(I.closedopen(0, 1), 0), (I.closedopen(1, 3), 1), (I.singleton(3), 2)])
assert d.keys() == [I.closedopen(0, 1), I.closedopen(1, 3), I.singleton(3)]
assert d.domain() == I.closed(0, 3)
assert d.values() == [0, 1, 2]
assert d.items() == list(zip(d.keys(), d.values()))
assert list(d) == d.keys()
# Iterators on empty
assert I.IntervalDict().values() == []
assert I.IntervalDict().items() == []
assert I.IntervalDict().keys() == []
assert I.IntervalDict().domain() == I.empty()
def test_union():
assert I.closed(1, 2).to_atomic() | I.closed(1, 2).to_atomic() == I.closed(1, 2).to_atomic()
assert I.closed(1, 4).to_atomic() | I.closed(2, 3).to_atomic() == I.closed(1, 4).to_atomic()
assert I.closed(1, 2).to_atomic() | I.closed(2, 3).to_atomic() == I.closed(2, 3).to_atomic() | I.closed(1, 2).to_atomic()
assert I.closed(1, 2).to_atomic() | I.closed(3, 4).to_atomic() == I.closed(1, 2) | I.closed(3, 4)
assert I.closed(1, 2) | I.closed(1, 2) == I.closed(1, 2)
assert I.closed(1, 4) | I.closed(2, 3) == I.closed(2, 3) | I.closed(1, 4)
assert I.closed(1, 4) | I.closed(2, 3) == I.closed(1, 4)
assert I.closed(1, 4) | I.closed(2, 3).to_atomic() == I.closed(1, 4)
assert I.closed(1, 4) | I.closed(2, 3).to_atomic() == I.closed(2, 3).to_atomic() | I.closed(1, 4)
assert I.closed(1, 2) | I.open(2, 3) == I.closedopen(1, 3)
assert I.closed(1, 3) | I.closed(2, 4) == I.closed(1, 4)
assert I.closed(1, 2) | I.closed(2, 3) == I.closed(2, 3) | I.closed(1, 2)
assert I.closedopen(1, 2) | I.closed(2, 3) == I.closed(1, 3)
assert I.open(1, 2) | I.closed(2, 4) == I.openclosed(1, 4)
assert I.closed(1, 2) | I.closed(3, 4) != I.closed(1, 4)
assert (I.closed(1, 2) | I.closed(3, 4) | I.closed(2, 3)).is_atomic()
assert I.closed(1, 2) | I.closed(3, 4) | I.closed(2, 3) == I.closed(1, 4)
assert I.closed(1, 2) | I.closed(0, 4) == I.closed(0, 4)
assert (I.closed(0, 1) | I.closed(2, 3) | I.closed(1, 2)).is_atomic()
assert I.closed(0, 1) | I.closed(2, 3) | I.closed(1, 2) == I.closed(0, 3)
assert I.closed(0, 1) | I.empty() == I.closed(0, 1)
# https://github.com/AlexandreDecan/python-intervals/issues/12
assert I.open(0, 2) | I.closed(0, 2) == I.closed(0, 2)
assert I.open(0, 2) | I.closed(1, 2) == I.openclosed(0, 2)
assert I.open(0, 2) | I.closed(0, 1) == I.closedopen(0, 2)
assert I.closed(0, 2) | I.open(0, 2) == I.closed(0, 2)
assert I.closed(1, 2) | I.open(0, 2) == I.openclosed(0, 2)
assert I.closed(0, 1) | I.open(0, 2) == I.closedopen(0, 2)
assert I.closed(0, 2) | I.singleton(2) == I.closed(0, 2)
assert I.closedopen(0, 2) | I.singleton(2) == I.closed(0, 2)
assert I.openclosed(0, 2) | I.singleton(2) == I.openclosed(0, 2)
assert I.openclosed(0, 2) | I.singleton(0) == I.closed(0, 2)
assert I.singleton(2) | I.closed(0, 2) == I.closed(0, 2)
assert I.singleton(2) | I.closedopen(0, 2) == I.closed(0, 2)
assert I.singleton(2) | I.openclosed(0, 2) == I.openclosed(0, 2)
assert I.singleton(0) | I.openclosed(0, 2) == I.closed(0, 2)
# https://github.com/AlexandreDecan/python-intervals/issues/13
assert I.closed(1, 1) | I.openclosed(1, 2) == I.closed(1, 2)
assert I.openclosed(1, 2) | I.closed(1, 1) == I.closed(1, 2)
assert I.closed(0, 1) | I.openclosed(1, 2) == I.closed(0, 2)
assert I.openclosed(1, 2) | I.closed(0, 1) == I.closed(0, 2)
assert I.openclosed(1, 2) | I.closed(1, 1) == I.closed(1, 2)
assert I.closed(1, 1) | I.openclosed(1, 2) == I.closed(1, 2)
assert I.openclosed(1, 2) | I.closed(0, 1) == I.closed(0, 2)
assert I.closed(0, 1) | I.openclosed(1, 2) == I.closed(0, 2)
def test_interval_constraints():
tests = {
I.closedopen(Version('1.0.0'), Version('3.0.0')): {
'strict': False,
'bounded': (True, True),
'soft': (False, True, True),
'hard': (True, True, True),
},
I.closedopen(Version('1.0.0'), Version('3.0.0')) | I.singleton(Version('4.0.0')): {
'strict': False,
'bounded': (True, True),
'soft': (False, False, False),
'hard': (True, True, True),
},
I.closed(Version('1.0.0'), Version('2.0.0')) | I.closedopen(Version('3.0.0'), Version('3.1.0')): {
'strict': False,
'bounded': (True, True),
'soft': (False, False, True),
'hard': (True, True, True),
},
I.closed(Version('1.0.0'), Version('2.0.0')) | I.closed(Version('3.0.0'), Version('3.1.0')): {
'strict': False,
'bounded': (True, True),
'soft': (False, False, True),
'hard': (True, True, True),
},
}
for constraint, expected in tests.items():
assert strict(constraint) == expected['strict']
assert (lower_bounded(constraint), upper_bounded(constraint)) == expected['bounded']
assert (allows_major(constraint), allows_minor(constraint), allows_patch(constraint)) == expected['soft']
assert (allows_major(constraint, soft=False), allows_minor(constraint, soft=False), allows_patch(constraint, soft=False)) == expected['hard']
def test_from_string_customized():
i1, i2, i3, i4 = '<"0"-"1">', '<!"0"-"1">', '<"0"-"1"!>', '<!"0"-"1"!>'
params = {
'conv': lambda s: int(s[1:-1]),
'disj': ' or ',
'sep': '-',
'left_open': '<!',
'left_closed': '<',
'right_open': '!>',
'right_closed': '>',
'pinf': r'\+oo',
'ninf': '-oo',
}
assert I.from_string(i1, **params) == I.closed(0, 1)
assert I.from_string(i2, **params) == I.openclosed(0, 1)
assert I.from_string(i3, **params) == I.closedopen(0, 1)
assert I.from_string(i4, **params) == I.open(0, 1)
assert I.from_string('<!!>', **params) == I.empty()
assert I.from_string('<"1">', **params) == I.singleton(1)
assert I.from_string('<!-oo-"1">', **params) == I.openclosed(-I.inf, 1)
assert I.from_string('<"1"-+oo!>', **params) == I.closedopen(1, I.inf)
assert I.from_string('<"0"-"1"> or <"2"-"3">', **params) == I.closed(0, 1) | I.closed(2, 3)
def test_to_string_customized():
i1, i2, i3, i4 = I.closed(0, 1), I.openclosed(0, 1), I.closedopen(0, 1), I.open(0, 1)
params = {
'disj': ' or ',
'sep': '-',
'left_open': '<!',
'left_closed': '<',
'right_open': '!>',
'right_closed': '>',
'conv': lambda s: '"{}"'.format(s),
'pinf': '+oo',
'ninf': '-oo',
}
assert I.to_string(i1, **params) == '<"0"-"1">'
assert I.to_string(i2, **params) == '<!"0"-"1">'
assert I.to_string(i3, **params) == '<"0"-"1"!>'
assert I.to_string(i4, **params) == '<!"0"-"1"!>'
assert I.to_string(I.empty(), **params) == '<!!>'
assert I.to_string(I.singleton(1), **params) == '<"1">'
assert I.to_string(I.openclosed(-I.inf, 1), **params) == '<!-oo-"1">'
assert I.to_string(I.closedopen(1, I.inf), **params) == '<"1"-+oo!>'
assert I.to_string(I.closed(0, 1) | I.closed(2, 3), **params) == '<"0"-"1"> or <"2"-"3">'
def test_creation():
assert I.closed(0, 1) == I.AtomicInterval(I.CLOSED, 0, 1, I.CLOSED)
assert I.open(0, 1) == I.AtomicInterval(I.OPEN, 0, 1, I.OPEN)
assert I.openclosed(0, 1) == I.AtomicInterval(I.OPEN, 0, 1, I.CLOSED)
assert I.closedopen(0, 1) == I.AtomicInterval(I.CLOSED, 0, 1, I.OPEN)
assert I.closed(-I.inf, I.inf) == I.open(-I.inf, I.inf)
assert I.singleton(2) == I.closed(2, 2)
assert I.Interval() == I.open(0, 0)
assert I.empty() == I.Interval()
assert I.closed(3, -3) == I.empty()
assert I.openclosed(3, 3) == I.empty()
# I.empty() is a singleton
assert I.empty() is I.empty()
assert I.Interval(I.closed(0, 1).to_atomic()) == I.closed(0, 1)
assert I.Interval(I.closed(0, 1)) == I.closed(0, 1)
assert I.Interval(I.closed(0, 1).to_atomic(),
I.closed(2, 3)) == I.closed(0, 1) | I.closed(2, 3)
assert I.Interval(I.closed(0, 1)
| I.closed(2, 3)) == I.closed(0, 1) | I.closed(2, 3)
with pytest.raises(TypeError):
I.Interval(1)
def include_literal(self, v, operator=None):
v = float(v.value)
#if operator is not None and operator in ["!=", "not in"]:
#self.values_repartition(v)
str_v = self.toString(v)
signature = "num_" + str_v
interval = I.singleton(v)
self.values.update({signature: interval})
return [signature]
def test_to_string():
i1, i2, i3, i4 = I.closed(0, 1), I.openclosed(0, 1), I.closedopen(0, 1), I.open(0, 1)
assert I.to_string(i1) == '[0,1]'
assert I.to_string(i2) == '(0,1]'
assert I.to_string(i3) == '[0,1)'
assert I.to_string(i4) == '(0,1)'
assert I.to_string(I.empty()) == '()'
assert I.to_string(I.singleton(1)) == '[1]'
assert I.to_string(I.closed(0, 1) | I.closed(2, 3)) == '[0,1] | [2,3]'
def test_creation():
assert I.closed(0, 1) == I.AtomicInterval(I.CLOSED, 0, 1, I.CLOSED)
assert I.open(0, 1) == I.AtomicInterval(I.OPEN, 0, 1, I.OPEN)
assert I.openclosed(0, 1) == I.AtomicInterval(I.OPEN, 0, 1, I.CLOSED)
assert I.closedopen(0, 1) == I.AtomicInterval(I.CLOSED, 0, 1, I.OPEN)
assert I.closed(-I.inf, I.inf) == I.open(-I.inf, I.inf)
with pytest.raises(ValueError):
I.closed(1, -1)
assert I.singleton(2) == I.closed(2, 2)
assert I.Interval() == I.open(0, 0)
assert I.empty() == I.Interval()
def test_replace_atomic():
i = I.closed(0, 1).to_atomic()
assert i.replace() == i
assert i.replace(I.OPEN, 2, 3, I.OPEN) == I.open(2, 3)
assert i.replace(upper=2, left=I.OPEN) == I.openclosed(0, 2)
assert i.replace(lower=lambda v: 1 + v) == I.singleton(1)
assert i.replace(left=lambda v: not v, right=lambda v: not v) == I.open(0, 1)
assert I.empty().to_atomic().replace(left=I.CLOSED, right=I.CLOSED) == I.empty()
assert I.empty().to_atomic().replace(lower=1, upper=2) == I.open(1, 2)
assert I.empty().to_atomic().replace(lower=lambda v: 1, upper=lambda v: 2) == I.empty()
assert I.empty().to_atomic().replace(lower=lambda v: 1, upper=lambda v: 2, ignore_inf=False) == I.open(1, 2)
def comparator_interval(op, version):
if op == '=':
return I.singleton(version)
if op == '<':
return I.closedopen(Version.FIRST, version)
if op == '<=':
return I.closed(Version.FIRST, version)
if op == '>':
return I.open(version, I.inf)
if op == '>=':
return I.closedopen(version, I.inf)
if op == '!=':
return I.closedopen(Version.FIRST, version) | I.openclosed(
version, I.inf)
def include_set(self, vls, operator=None):
rt = []
values = vls.values
#if operator is not None and operator in ["!=", "not in"]:
# for v in values:
# self.values_repartition(v)
for v in values:
v = float(v.value)
str_v = self.toString(v)
signature = "num_" + str_v
interval = I.singleton(v)
self.values.update({signature: interval})
rt.append(signature)
return rt
def test_from_string():
i1, i2, i3, i4 = '[0,1]', '(0,1]', '[0,1)', '(0,1)'
assert I.from_string(i1, int) == I.closed(0, 1)
assert I.from_string(i2, int) == I.openclosed(0, 1)
assert I.from_string(i3, int) == I.closedopen(0, 1)
assert I.from_string(i4, int) == I.open(0, 1)
assert I.from_string('()', int) == I.empty()
assert I.from_string('[1]', int) == I.singleton(1)
assert I.from_string('[0,1] | [2,3]', int) == I.closed(0, 1) | I.closed(2, 3)
with pytest.raises(Exception):
I.from_string('[1,2]', None)
def test_intervaldict_combine():
add = lambda x, y: x + y
assert I.IntervalDict().combine(I.IntervalDict(), add) == I.IntervalDict()
d = I.IntervalDict([(I.closed(0, 3), 0)])
assert I.IntervalDict().combine(d, add) == d
assert d.combine(I.IntervalDict(), add) == d
d1 = I.IntervalDict([(I.closed(1, 3) | I.closed(5, 7), 1)])
d2 = I.IntervalDict([(I.closed(2, 4) | I.closed(6, 8), 2)])
assert d1.combine(d2, add) == d2.combine(d1, add)
assert d1.combine(d2, add) == I.IntervalDict([
(I.closedopen(1, 2) | I.closedopen(5, 6), 1),
(I.closed(2, 3) | I.closed(6, 7), 3),
(I.openclosed(3, 4) | I.openclosed(7, 8), 2),
])
d1 = I.IntervalDict({
I.closed(0, 1): 2,
I.closed(3, 4): 2
})
d2 = I.IntervalDict({
I.closed(1, 3): 3,
I.closed(4, 5): 1
})
assert d1.combine(d2, add) == d2.combine(d1, add)
assert d1.combine(d2, add) == I.IntervalDict({
I.closedopen(0, 1): 2,
I.singleton(1): 5,
I.open(1, 3): 3,
I.singleton(3): 5,
I.open(3, 4): 2,
I.singleton(4): 3,
I.openclosed(4, 5): 1,
})
def test_intervaldict_get_set():
d = I.IntervalDict()
# Single value
d[I.closed(0, 2)] = 0
assert len(d) == 1
assert d[2] == 0
assert d.get(2) == 0
with pytest.raises(KeyError):
d[3]
assert d.get(3) is None
# Intervals
d = I.IntervalDict([(I.closed(0, 2), 0)])
assert d[I.open(-I.inf, I.inf)].items() == [(I.closed(0, 2), 0)]
assert d[I.closed(0, 2)].items() == [(I.closed(0, 2), 0)]
assert d[I.closed(-1, 0)].items() == [(I.singleton(0), 0)]
assert d[I.closed(-2, -1)].items() == []
assert d.get(I.closed(0, 2)).items() == [(I.closed(0, 2), 0)]
assert d.get(I.closed(-2, -1)).items() == [(I.closed(-2, -1), None)]
assert d.get(I.closed(-1, 0)).items() == [(I.closedopen(-1, 0), None), (I.singleton(0), 0)]
d[I.closed(1, 3)] = 1
assert d.items() == [(I.closedopen(0, 1), 0), (I.closed(1, 3), 1)]
assert len(d) == 2
assert d[0] == 0
assert d.get(0, -1) == 0
assert d[1] == 1
assert d.get(1, -1) == 1
assert d[3] == 1
assert d.get(3, -1) == 1
with pytest.raises(KeyError):
d[4]
assert d.get(4, -1) == -1
# Set values
d = I.IntervalDict([(I.closed(0, 2), 0)])
d[3] = 2
assert d.items() == [(I.closed(0, 2), 0), (I.singleton(3), 2)]
d[3] = 3
assert d.items() == [(I.closed(0, 2), 0), (I.singleton(3), 3)]
d[I.closed(0, 2)] = 1
assert d.items() == [(I.closed(0, 2), 1), (I.singleton(3), 3)]
d[I.closed(-1, 1)] = 2
assert d.items() == [(I.closed(-1, 1), 2), (I.openclosed(1, 2), 1), (I.singleton(3), 3)]
d = I.IntervalDict([(I.closed(0, 2), 0)])
d[I.closed(-1, 4)] = 1
assert d.items() == [(I.closed(-1, 4), 1)]
d[I.closed(5, 6)] = 1
assert d.items() == [(I.closed(-1, 4) | I.closed(5, 6), 1)]
# Delete
d = I.IntervalDict([(I.closed(0, 2), 0)])
del d[1]
with pytest.raises(KeyError):
d[1]
with pytest.raises(KeyError):
del d[3]
d = I.IntervalDict([(I.closed(0, 2), 0)])
del d[I.closed(-1, 1)]
assert d.items() == [(I.openclosed(1, 2), 0)]
del d[I.closed(-10, -9)]
assert d.items() == [(I.openclosed(1, 2), 0)]
del d[I.empty()]
assert d.items() == [(I.openclosed(1, 2), 0)]
# setdefault
d = I.IntervalDict([(I.closed(0, 2), 0)])
assert d.setdefault(-1, default=0) == 0
assert d[-1] == 0
assert d.setdefault(0, default=1) == 0
assert d[0] == 0
d = I.IntervalDict([(I.closed(0, 2), 0)])
t = d.setdefault(I.closed(-2, -1), -1)
assert t.items() == [(I.closed(-2, -1), -1)]
assert d.items() == [(I.closed(-2, -1), -1), (I.closed(0, 2), 0)]
d = I.IntervalDict([(I.closed(0, 2), 0)])
t = d.setdefault(I.closed(-1, 1), 2)
assert t.items() == [(I.closedopen(-1, 0), 2), (I.closed(0, 1), 0)]
assert d.items() == [(I.closedopen(-1, 0), 2), (I.closed(0, 2), 0)]
