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)]