def test___isub__():
"""Test -= operator for AttributeSystem."""
a = Attribute("a", [])
b = Attribute("b", [])
R1 = Relation("R1(a) <=> ", ["a"], 1)
R2 = Relation("R2(a) <=> ", ["b"], 2)
astr_empty = AttributeStructure()
astr_a = AttributeStructure(a)
astr_a_b = AttributeStructure(a, b)
astr_a_R1 = AttributeStructure(a, R1)
astr_a_b_R1 = AttributeStructure(a, b, R1)
astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
objs = ['a', 'b', 'c']
asys = AttributeSystem(astr_empty, [])
asys_a = AttributeSystem(astr_a, [])
asys_a_b = AttributeSystem(astr_a_b, [])
asys_a_R1 = AttributeSystem(astr_a_R1, [])
asys_a_b_R1 = AttributeSystem(astr_a_b_R1, [])
asys_a_b_R1_R2 = AttributeSystem(astr_a_b_R1_R2, [])
asys_a_b_R1_R2 -= R2
assert asys_a_b_R1_R2 == asys_a_b_R1
assert asys_a_b_R1_R2 is not asys_a_b_R1
asys_a_b_R1_R2 -= R1
assert asys_a_b_R1_R2 == asys_a_b
assert asys_a_b_R1_R2 is not asys_a_b
asys_a_b_R1_R2 -= b
assert asys_a_b_R1_R2 == asys_a
assert asys_a_b_R1_R2 is not asys_a
asys_a_b_R1_R2 -= a
assert asys_a_b_R1_R2 == asys
assert asys_a_b_R1_R2 is not asys
def test___getitem__():
"""Test indexing of AttributeSystem."""
a = Attribute("a", [])
b = Attribute("b", [])
R1 = Relation("R1(a) <=> ", ["a"], 1)
R2 = Relation("R2(a) <=> ", ["b"], 2)
astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
objs = ['a', 'b', 'c']
asys_a_b_R1_R2_o = AttributeSystem(astr_a_b_R1_R2, objs)
ia = asys_a_b_R1_R2_o[a]
assert ia == a
assert ia is asys_a_b_R1_R2_o._attribute_structure["a"]
iR1 = asys_a_b_R1_R2_o[R1]
assert iR1 == R1
assert iR1 is asys_a_b_R1_R2_o._attribute_structure["R1"]
# Test object retrieval with string. Note, strings may not index
# AttributeStructure members within this AttributeSystem, only objects.
# To index objects in AttributeStructure in AttributeSystem, use index
# with asys.astr[index]
iobj = asys_a_b_R1_R2_o['a']
assert iobj == objs[0]
assert iobj is objs[0]
# Test retrieval by string for AttributeStructure members
# AttributeStructure is cloned so the retrieved objects is not the same
# as the one's used to contruct original instance
ias = asys_a_b_R1_R2_o._attribute_structure['a']
assert ias == a
assert ias is not a
iR1s = asys_a_b_R1_R2_o._attribute_structure['R1']
assert iR1s == R1
assert iR1s is not R1
def test___ne__():
"""Test != operator for ConstantAssignment object."""
vocabulary1 = Vocabulary(['C'], [RelationSymbol('R', 1)], ['V'])
vocabulary2 = Vocabulary(['C\''], [RelationSymbol('R\'', 1)], ['V\''])
a = Attribute("a", [])
b = Attribute("b", [])
astr1 = AttributeStructure(a, b)
astr2 = AttributeStructure(b)
objs1 = ['a', 'b', 'c']
objs2 = ['a']
attribute_system1 = AttributeSystem(astr1, objs1)
attribute_system2 = AttributeSystem(astr2, objs2)
mapping1 = {'C': 'a'}
mapping2 = {'C': 'b'}
A1 = ConstantAssignment(vocabulary1, attribute_system1, mapping1)
A2 = ConstantAssignment(vocabulary1, attribute_system1, mapping1)
A3 = ConstantAssignment(vocabulary2, attribute_system1, {})
A4 = ConstantAssignment(vocabulary1, attribute_system2, {})
A5 = ConstantAssignment(vocabulary1, attribute_system1, mapping2)
assert not A1 != A1
assert not A1 != A2
assert A1 != A3
assert A1 != A4
assert A1 != A5
def test___repr__():
"""Test repr(AttributeInterpretation)."""
a = Attribute('hour', ['0,...,23'])
a2 = Attribute('minute', ['0,...,59'])
r_ahead = Relation('R1(h1,m1,h2,m2) <=> h1 > h2 or (h1 = h2 and m1 > m2)',
['hour', 'minute', 'hour', 'minute'], 1)
r_behind = Relation('R2(h1,m1,h2,m2) <=> h1 < h2 or (h1 = h2 and m1 < m2)',
['hour', 'minute', 'hour', 'minute'], 2)
r_pm = Relation('R3(h1) <=> h1 > 12', ['hour'], 3)
r_am = Relation('R4(h1) <=> h1 < 12', ['hour'], 4)
attribute_structure = AttributeStructure(
a, a2, r_ahead, r_behind, r_pm, r_am)
ahead_rs = RelationSymbol('Ahead', 4)
behind_rs = RelationSymbol('Behind', 4)
pm_rs = RelationSymbol('PM', 1)
vocabulary = Vocabulary(
['C1', 'C2'], [ahead_rs, behind_rs, pm_rs], ['V1', 'V2'])
profiles = [
[ahead_rs, ('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)],
[behind_rs, ('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)],
[pm_rs, ('hour', 1)]
]
mapping = {ahead_rs: 1, behind_rs: 2, pm_rs: 3}
ai = AttributeInterpretation(
vocabulary, attribute_structure, mapping, profiles)
assert repr(ai) == "[Ahead, 4, 'R1', [('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)]]\n" + \
"[Behind, 4, 'R2', [('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)]]\n" + \
"[PM, 1, 'R3', [('hour', 1)]]"
def test___le__():
"""Test overloaded <= subset operator for ConstantAssignment."""
vocabulary1 = Vocabulary(['C1', 'C2', 'C3'], [RelationSymbol('R', 1)],
['V'])
vocabulary2 = Vocabulary(['C\''], [RelationSymbol('R\'', 1)], ['V\''])
a = Attribute("a", [])
b = Attribute("b", [])
astr1 = AttributeStructure(a, b)
astr2 = AttributeStructure(b)
objs1 = ['a', 'b', 'c']
objs2 = ['a']
attribute_system1 = AttributeSystem(astr1, objs1)
attribute_system2 = AttributeSystem(astr2, objs2)
mapping1 = {'C1': 'a'}
mapping2 = {'C1': 'a', 'C2': 'b'}
mapping3 = {'C1': 'a', 'C2': 'b', 'C3': 'c'}
mapping4 = {'C\'': 'a'}
mapping5 = {'C1': 'b'}
CA1 = ConstantAssignment(vocabulary1, attribute_system1, mapping1)
CA2 = ConstantAssignment(vocabulary1, attribute_system1, mapping2)
CA3 = ConstantAssignment(vocabulary1, attribute_system1, mapping3)
CA4 = ConstantAssignment(vocabulary2, attribute_system2, mapping4)
CA5 = ConstantAssignment(vocabulary1, attribute_system1, mapping5)
assert CA1 <= CA1
assert CA1 <= CA2
assert CA1 <= CA2 <= CA3
assert not CA1 <= CA4
assert not CA4 <= CA1
assert not CA5 <= CA2
def test___add__():
"""Test + operator."""
from vivid.classes.relation import Relation
from vivid.classes.attribute_structure import AttributeStructure
a1 = Attribute("a1", [])
a2 = Attribute("a2", [])
r1 = Relation("R1(a) <=> ", ["a1"], 1)
astr = AttributeStructure()
astr_a1 = AttributeStructure(a1)
astr_a1_a2 = AttributeStructure(a1, a2)
astr_a1_r1 = AttributeStructure(a1, r1)
astr_a1_a2_r1 = AttributeStructure(a1, a2, r1)
# add AttributeStructure and Attribute
assert astr_a1 == astr + a1
assert astr_a1 == a1 + astr
# add Attribute and Attribute
assert astr_a1_a2 == a1 + a2
assert astr_a1_a2 == a2 + a1
# add Attribute and Relation
assert astr_a1_r1 == a1 + r1
assert astr_a1_r1 == r1 + a1
assert astr_a1_a2_r1 == a1 + a2 + r1
assert astr_a1_a2_r1 == a2 + a1 + r1
assert astr_a1_a2_r1 == r1 + a1 + a2
# Test for when + fails, i.e. when Relation is added before attributes with
# its D(R) labels.
with pytest.raises(ValueError) as excinfo:
r1 + a2 + a1
def test___deepcopy__():
"""Test deepcopy"""
color = Attribute("color", ['R', 'G', 'B'])
size = Attribute("size", ['S', 'M', 'L'])
a = AttributeStructure(color, size)
o = ['s1', 's2']
asys = AttributeSystem(a, o)
ascr = {
('color', 's1'): ['R'],
('color', 's2'): ['B', 'G'],
('size', 's1'): ['M'],
('size', 's2'): ['L', 'S']
}
s = State(asys, ascr)
from copy import deepcopy
s_copy = deepcopy(s)
assert s == s_copy
assert s is not s_copy
assert s._attribute_system == s_copy._attribute_system
assert s._attribute_system is not s_copy._attribute_system
assert s._ascriptions == s_copy._ascriptions
assert s._ascriptions is not s_copy._ascriptions
def test___getitem__():
"""Test indexing of AttributeStructure."""
def test_TypeError(astr, index):
"""Test indexing for TypeErrors with given params."""
with pytest.raises(TypeError) as excinfo:
astr[index]
def test_KeyError(astr, index):
"""Test indexing for ValueErrors with given params."""
with pytest.raises(KeyError) as excinfo:
astr[index]
a = Attribute("a", [])
b = Attribute("b", [])
R1 = Relation("R1(a) <=> ", ["a"], 1)
R2 = Relation("R2(b) <=> ", ["b"], 2)
astr = AttributeStructure(a, R1)
assert astr[a] == a
assert astr[R1] == R1
assert astr["a"] == a
assert astr["R1"] == R1
assert astr[1] == R1
test_TypeError(astr, None)
test_TypeError(astr, 1.0)
test_TypeError(astr, [])
test_TypeError(astr, object)
test_KeyError(astr, "")
test_KeyError(astr, 3)
test_KeyError(astr, b)
test_KeyError(astr, R2)
def test___getitem__():
"""Test indexing for VariableAssignment object."""
def test_TypeError(variable_assignment, key):
"""Test constructor for TypeErrors with given params."""
with pytest.raises(TypeError) as excinfo:
variable_assignment[key]
def test_KeyError(variable_assignment, key):
"""Test constructor for KeyErrors with given params."""
with pytest.raises(KeyError) as excinfo:
variable_assignment[key]
vocabulary = Vocabulary(['C'], [RelationSymbol('R', 1)], ['V'])
a = Attribute("a", [])
b = Attribute("b", [])
astr = AttributeStructure(a, b)
objs = ['a', 'b', 'c']
attribute_system = AttributeSystem(astr, objs)
mapping = {'V': 'a'}
VA = VariableAssignment(vocabulary, attribute_system, mapping)
test_TypeError(VA, 1)
test_TypeError(VA, None)
test_TypeError(VA, object)
test_KeyError(VA, '')
assert VA['V'] == 'a'
def test___le__():
"""Test total ordering."""
a = Attribute("a", [])
b = Attribute("b", [])
R1 = Relation("R1(a) <=> ", ["a"], 1)
R2 = Relation("R2(a) <=> ", ["b"], 2)
astr_empty = AttributeStructure()
astr_a = AttributeStructure(a)
astr_a_R1 = AttributeStructure(a, R1)
astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
# Test subsets and strict subsets
assert not astr_empty < astr_empty
assert astr_empty <= astr_empty
assert astr_empty < astr_a_b_R1_R2
assert astr_empty <= astr_a_b_R1_R2
assert astr_a < astr_a_b_R1_R2
assert astr_a <= astr_a_b_R1_R2
assert astr_a_R1 < astr_a_b_R1_R2
assert astr_a_R1 <= astr_a_b_R1_R2
assert not astr_a_b_R1_R2 < astr_a_b_R1_R2
assert astr_a_b_R1_R2 <= astr_a_b_R1_R2
# Test supersets and strict supersets
assert not astr_empty > astr_empty
assert astr_empty >= astr_empty
assert astr_a_b_R1_R2 > astr_empty
assert astr_a_b_R1_R2 >= astr_empty
assert astr_a_b_R1_R2 > astr_a
assert astr_a_b_R1_R2 >= astr_a
assert astr_a_b_R1_R2 > astr_a_R1
assert astr_a_b_R1_R2 >= astr_a_R1
assert not astr_a_b_R1_R2 > astr_a_b_R1_R2
assert astr_a_b_R1_R2 >= astr_a_b_R1_R2
def test___init__():
"""Test VariableAssignment constructor."""
def test_TypeError(vocabulary, attribute_system, mapping):
"""Test constructor for TypeErrors with given params."""
with pytest.raises(TypeError) as excinfo:
VariableAssignment(vocabulary, attribute_system, mapping)
def test_ValueError(vocabulary, attribute_system, mapping):
"""Test constructor for ValueErrors with given params."""
with pytest.raises(ValueError) as excinfo:
VariableAssignment(vocabulary, attribute_system, mapping)
vocabulary = Vocabulary(['C'], [RelationSymbol('R', 1)], ['V'])
a = Attribute("a", [])
b = Attribute("b", [])
astr = AttributeStructure(a, b)
objs = ['a', 'b', 'c']
attribute_system = AttributeSystem(astr, objs)
test_TypeError(vocabulary, attribute_system, {'V': 1})
test_TypeError(vocabulary, attribute_system, {1: 'a'})
test_ValueError(vocabulary, attribute_system, {'V': 'bad'})
test_ValueError(vocabulary, attribute_system, {'bad': 'a'})
VA = VariableAssignment(vocabulary, attribute_system, {'V': 'a'})
def test___init__():
"""Test AttributeStructure construction."""
def test_TypeError(*ops):
"""Test constructor for TypeErrors with given params."""
with pytest.raises(TypeError) as excinfo:
AttributeStructure(*ops)
def test_ValueError(*ops):
"""Test constructor for TypeErrors with given params."""
with pytest.raises(ValueError) as excinfo:
AttributeStructure(*ops)
# Test bad optional param
test_TypeError("a")
test_TypeError(object)
a = Attribute("a", [])
b = Attribute("b", [])
R1 = Relation("R1(a) <=> ", ["a1"], 1)
R2 = Relation("R2(a) <=> ", ["b"], 2)
R3 = Relation("R3(a) <=> ", ["a"], 3)
# Test no duplicate labels
test_ValueError(a, a)
# Test no duplicate subscripts
test_ValueError(R1, R1)
# Test D(R) subset of labels
test_ValueError(a, R1)
# Test out of order construction
AttributeStructure(R2, R3, b, a)
def test___eq__():
"""Test == operator for AttributeSystem."""
a = Attribute("a", [])
b = Attribute("b", [])
R1 = Relation("R1(a) <=> ", ["a"], 1)
R2 = Relation("R2(a) <=> ", ["b"], 2)
astr_empty = AttributeStructure()
astr_a_b = AttributeStructure(a, b)
astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
objs_empty = []
objs = ['a', 'b', 'c']
asys = AttributeSystem(astr_empty, objs_empty)
asys_o = AttributeSystem(astr_empty, objs)
asys_o_copy = AttributeSystem(astr_empty, objs)
asys_a_b = AttributeSystem(astr_a_b, objs_empty)
asys_a_b_copy = AttributeSystem(astr_a_b, objs_empty)
asys_a_b_R1_R2 = AttributeSystem(astr_a_b_R1_R2, objs_empty)
asys_a_b_R1_R2_copy = AttributeSystem(astr_a_b_R1_R2, objs_empty)
asys_a_b_R1_R2_o = AttributeSystem(astr_a_b_R1_R2, objs)
asys_a_b_R1_R2_o_copy = AttributeSystem(astr_a_b_R1_R2, objs)
# test identity
assert asys == asys
# components tests
assert asys_o == asys_o_copy
assert asys_a_b == asys_a_b_copy
assert asys_a_b_R1_R2 == asys_a_b_R1_R2_copy
assert asys_a_b_R1_R2_o == asys_a_b_R1_R2_o_copy
def test_get_labels():
"""Test get_labels function."""
a = Attribute("a", [])
b = Attribute("b", [])
c = Attribute("c", [])
astr = AttributeStructure(a, b, c)
assert astr.get_labels() == ['a', 'b', 'c']
def test_get_cardinality():
"""Test get cardinality of this AttributeStructure."""
a = Attribute("a", [])
b = Attribute("b", [])
c = Attribute("c", [])
d = Attribute("d", [])
astr = AttributeStructure(a, b, c, d)
assert astr.get_cardinality() == 4
def test_set_ascription():
"""Test set_ascription function."""
def test_TypeError(state, ascription, valueset):
"""Test set_ascription for TypeErrors with given params."""
with pytest.raises(TypeError) as excinfo:
state.set_ascription(ascription, valueset)
def test_ValueError(state, ascription, valueset):
"""Test set_ascription for ValueErrors with given params."""
with pytest.raises(ValueError) as excinfo:
state.set_ascription(ascription, valueset)
def test_KeyError(state, ascription, valueset):
"""Test set_ascription for KeyErrors with given params."""
with pytest.raises(KeyError) as excinfo:
state.set_ascription(ascription, valueset)
color = Attribute("color", ['R', 'G', 'B'])
size = Attribute("size", ['S', 'M', 'L'])
a = AttributeStructure(color, size)
o = ['s1', 's2']
asys = AttributeSystem(a, o)
s = State(asys)
# test bad ao_pair types/values
test_TypeError(s, [], ['R'])
test_ValueError(s, (), ['R'])
test_ValueError(s, (1, 2, 3), ['R'])
test_ValueError(s, (1, 2), ['R'])
test_ValueError(s, (1, ''), ['R'])
test_ValueError(s, ('', 1), ['R'])
# test bad types for ValueSet
test_TypeError(s, ('color', 's1'), None)
test_TypeError(s, ('color', 's1'), ())
test_TypeError(s, ('color', 's1'), 'a')
test_TypeError(s, ('color', 's1'), object)
# test empty ValueSet catching
test_ValueError(s, ('color', 's1'), [])
test_ValueError(s, ('color', 's1'), set([]))
test_ValueError(s, ('color', 's1'), ValueSet([]))
# test bad ao-pair keys
test_KeyError(s, ('color', 'bad object'), ['R'])
test_KeyError(s, ('bad label', 's2'), ['R'])
# test nonsubset valuesets
test_ValueError(s, ('color', 's2'), ['a'])
test_ValueError(s, ('color', 's2'), [1])
s.set_ascription(('color', 's2'), ['R'])
assert s[('color', 's2')] == ValueSet(['R'])
# check reversion to superset is possible
s.set_ascription(('color', 's2'), ['R', 'G'])
assert s[('color', 's2')] == ValueSet(['R', 'G'])
s.set_ascription(('size', 's1'), ['M', 'S'])
assert s[('size', 's1')] == ValueSet(['S', 'M'])
def test_get_worlds():
"""Test get_worlds function."""
color = Attribute("color", ['R', 'G', 'B'])
size = Attribute("size", ['S', 'M', 'L'])
a = AttributeStructure(color, size)
o = ['s1', 's2']
asys = AttributeSystem(a, o)
ascr = {
('color', 's1'): ['R'],
('color', 's2'): ['B', 'G'],
('size', 's1'): ['M'],
('size', 's2'): ['L', 'S']
}
ascr1 = {
('color', 's1'): ['R'],
('color', 's2'): ['G'],
('size', 's1'): ['M'],
('size', 's2'): ['L']
}
ascr2 = {
('color', 's1'): ['R'],
('color', 's2'): ['G'],
('size', 's1'): ['M'],
('size', 's2'): ['S']
}
ascr3 = {
('color', 's1'): ['R'],
('color', 's2'): ['B'],
('size', 's1'): ['M'],
('size', 's2'): ['L']
}
ascr4 = {
('color', 's1'): ['R'],
('color', 's2'): ['B'],
('size', 's1'): ['M'],
('size', 's2'): ['S']
}
s = State(asys, ascr)
w1 = State(asys, ascr1)
w2 = State(asys, ascr2)
w3 = State(asys, ascr3)
w4 = State(asys, ascr4)
worlds = [w1, w2, w3, w4]
for w in s.get_worlds():
assert w in worlds
assert len(s.get_worlds()) == len(worlds)
def test___repr__():
"""Test repr(AttributeStructure)."""
a = Attribute("a", [])
b = Attribute("b", [])
R1 = Relation("R1(a) <=> ", ["a"], 1)
R2 = Relation("R2(a) <=> ", ["b"], 2)
astr = AttributeStructure(a, b, R1, R2)
astr2 = AttributeStructure(R2, R1, b, a)
assert str(astr) == "(a: {}, b: {} ; R1,R2)"
assert str(astr2) == "(a: {}, b: {} ; R1,R2)"
def test___repr__():
"""Test repr()."""
a = Attribute("a", [])
b = Attribute("b", [])
R1 = Relation("R1(a) <=> ", ["a"], 1)
R2 = Relation("R2(a) <=> ", ["b"], 2)
astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
objs = ['a', 'b', 'c']
asys_a_b_R1_R2_o = AttributeSystem(astr_a_b_R1_R2, objs)
assert repr(asys_a_b_R1_R2_o) == "({a, b, c} ; (a: {}, b: {} ; R1,R2))"
assert repr(AttributeSystem(AttributeStructure(), [])) == "({} ; ( ; ))"
def test___deepcopy__():
"""Test copy.deepcopy for AttributeStructure object."""
import copy
a = Attribute("a", [])
b = Attribute("b", [])
R1 = Relation("R1(a) <=> ", ["a"], 1)
R2 = Relation("R2(a) <=> ", ["b"], 2)
astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
astr_copy = copy.deepcopy(astr_a_b_R1_R2)
assert astr_copy == astr_a_b_R1_R2
assert astr_copy._attributes is not astr_a_b_R1_R2._attributes
assert astr_copy._relations is not astr_a_b_R1_R2._relations
assert astr_copy is not astr_a_b_R1_R2
def test__key():
"""Test Attribute hash key."""
A = Attribute("", [])
A2 = Attribute("label", [1, 'string', True])
assert A._key() == ("", 'V()')
print A2._key()
assert A2._key() == ('label', 'V(1, string, True)')
def test___isub__():
"""Test -= operator for AttributeStructure."""
def test_ValueError(astr, sub):
"""Test constructor for TypeErrors with given params."""
with pytest.raises(ValueError) as excinfo:
astr -= sub
def test_KeyError(astr, sub):
"""Test constructor for TypeErrors with given params."""
with pytest.raises(KeyError) as excinfo:
astr -= sub
def test_TypeError(astr, sub):
"""Test constructor for TypeErrors with given params."""
with pytest.raises(TypeError) as excinfo:
astr -= sub
a = Attribute("a", [])
b = Attribute("b", [])
R1 = Relation("R1(a) <=> ", ["a"], 1)
R2 = Relation("R2(a) <=> ", ["b"], 2)
astr_empty = AttributeStructure()
astr_a = AttributeStructure(a)
astr_a_R1 = AttributeStructure(a, R1)
astr_a_b = AttributeStructure(a, b)
astr_a_b_R1 = AttributeStructure(a, b, R1)
astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
# Test invalid subtraction error catching
test_KeyError(astr_empty, a)
test_KeyError(astr_empty, R1)
test_TypeError(astr_empty, None)
test_TypeError(astr_empty, "")
test_TypeError(astr_empty, object)
test_ValueError(astr_empty, astr_a)
test_ValueError(astr_empty, astr_a_R1)
astr_a_copy = AttributeStructure(a)
test_ValueError(astr_a, astr_a_R1)
assert astr_a_copy == astr_a
# Test attribute removal
astr_a_b_R1_R2 -= R2
assert astr_a_b_R1 == astr_a_b_R1_R2
astr_a_b_R1_R2 -= R1
assert astr_a_b == astr_a_b_R1_R2
astr_a_b_R1_R2 -= b
assert astr_a == astr_a_b_R1_R2
astr_a_b_R1_R2 -= a
assert astr_empty == astr_a_b_R1_R2
def test_is_alternate_extension():
"""Test is_alternate_extension function."""
from copy import deepcopy
color, size = Attribute("color", ['R', 'G', 'B']), Attribute(
"size", ['S', 'M', 'L'])
a = AttributeStructure(color, size)
o = ['s1', 's2']
asys = AttributeSystem(a, o)
s = State(asys)
s.set_ascription(('color', 's1'), ['R', 'B'])
s.set_ascription(('size', 's2'), ['M', 'L'])
s1 = deepcopy(s)
s1.set_ascription(('color', 's1'), ['B'])
s1.set_ascription(('size', 's1'), ['S', 'M'])
s1.set_ascription(('color', 's2'), ['B', 'G'])
s2 = deepcopy(s)
s2.set_ascription(('size', 's1'), ['L'])
s2.set_ascription(('size', 's2'), ['L'])
s3 = deepcopy(s)
s3.set_ascription(('color', 's1'), ['R'])
aes = s.get_alternate_extensions(s1, s2, s3)
ae_s5, ae_s6, ae_s4 = aes
for ae in aes:
print s.is_alternate_extension(ae, s1, s2, s3)
color, size = Attribute("color", ['R', 'G', 'B']), Attribute(
"size", ['S', 'M', 'L'])
a = AttributeStructure(color, size)
o = ['s']
asys = AttributeSystem(a, o)
s = State(asys)
s1 = deepcopy(s)
s1.set_ascription(('color', 's'), ['B', 'G'])
s1.set_ascription(('size', 's'), ['S'])
aes = s.get_alternate_extensions(s1)
ae_s2, ae_s3 = aes
for ae in aes:
print s.is_alternate_extension(ae, s1)
def test___repr__():
"""Test repr(VariableAssignment)."""
vocabulary = Vocabulary(['C', 'C\''], [RelationSymbol('R', 1)], ['V'])
a = Attribute("a", [])
b = Attribute("b", [])
astr = AttributeStructure(a, b)
objs = ['a', 'b', 'c']
attribute_system = AttributeSystem(astr, objs)
mapping = {'V': 'a'}
VA = VariableAssignment(vocabulary, attribute_system, mapping)
assert VA.__repr__() == "VA{'V': 'a'}"
def test___ne__():
"""!= operator for AttributeStructure."""
a1 = Attribute("a1", [])
a2 = Attribute("a2", [])
R1 = Relation("R1(a) <=> ", ["a1"], 1)
R2 = Relation("R2(a) <=> ", ["a1"], 2)
astr1 = AttributeStructure(a1, a2, R1, R2)
astr2 = AttributeStructure(a1, R2)
astr3 = AttributeStructure()
# strict subset-superset tests
assert astr1 != astr2
assert astr2 != astr1
# empty comparison test
assert astr1 != astr3
assert astr3 != astr1
def test_is_automorphic():
"""Test if system is automorphic."""
a = Attribute("a", [])
b = Attribute("b", [])
c = Attribute("c", ['a'])
R1 = Relation("R1(a) <=> ", ["a"], 1)
R2 = Relation("R2(a) <=> ", ["b"], 2)
astr_c = AttributeStructure(c)
astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
objs = ['a', 'b', 'c']
asys_a_b_R1_R2_o = AttributeSystem(astr_a_b_R1_R2, objs)
asys_auto = AttributeSystem(astr_c, objs)
assert asys_auto.is_automorphic()
assert not asys_a_b_R1_R2_o.is_automorphic()
def test___deepcopy__():
"""Test copy.deepcopy functionality of Attribute object."""
from copy import deepcopy
a = Attribute("label", ["v1", "v2"])
a_copy = deepcopy(a)
assert a == a_copy
assert a is not a_copy
def test_join():
"""Test join function for States."""
def test_ValueError(s1, s2):
"""Test constructor for ValueErrors with given params."""
with pytest.raises(ValueError) as excinfo:
State.join(s1, s2)
color = Attribute("color", ['R', 'G', 'B'])
size = Attribute("size", ['S', 'M', 'L'])
a = AttributeStructure(color, size)
o = ['s1', 's2']
asys = AttributeSystem(a, o)
ascr1 = {
('color', 's1'): ['R'],
('color', 's2'): ['B'],
('size', 's1'): ['M'],
('size', 's2'): ['L', 'S']
}
ascr2 = {
('color', 's1'): ['G'],
('color', 's2'): ['G'],
('size', 's1'): ['L'],
('size', 's2'): ['M', 'S']
}
ascr3 = {
('color', 's1'): ['R', 'G'],
('color', 's2'): ['B', 'G'],
('size', 's1'): ['L', 'M'],
('size', 's2'): ['M', 'S', 'L']
}
s1 = State(asys, ascr1)
s2 = State(asys, ascr2)
s3 = State(asys, ascr3)
assert s3 == State.join(s1, s2)
length = Attribute("length", [1, 3, 5])
shape = Attribute("shape", ['circle', 'triangle', 'rectangle'])
a = AttributeStructure(length, shape)
o = ['s1', 's2']
bad_asys = AttributeSystem(a, o)
bad_state = State(bad_asys)
test_ValueError(s1, bad_state)
def test_get_subscripts():
"""Test retrieval of subscripts from Relation's in AttributeStructure."""
a = Attribute("a", [])
R1 = Relation("R1(a) <=> ", ["a"], 1)
R2 = Relation("R2(a) <=> ", ["a"], 2)
R3 = Relation("R3(a) <=> ", ["a"], 3)
R4 = Relation("R4(a) <=> ", ["a"], 4)
astr = AttributeStructure(a, R1, R2, R3, R4)
assert astr.get_subscripts() == [1, 2, 3, 4]
def test___repr__():
"""Test repr(ConstantAssignment)."""
vocabulary = Vocabulary(['C', 'C\''], [RelationSymbol('R', 1)], ['V'])
a = Attribute("a", [])
b = Attribute("b", [])
astr = AttributeStructure(a, b)
objs = ['a', 'b', 'c']
attribute_system = AttributeSystem(astr, objs)
mapping = {'C': 'a'}
mapping2 = {'C': 'a', 'C\'': 'b'}
CA = ConstantAssignment(vocabulary, attribute_system, mapping)
CA2 = ConstantAssignment(vocabulary, attribute_system, mapping2)
assert CA.__repr__() == "CA{'C': 'a'}"
assert CA2.__repr__() == "CA{'C': 'a', \"C\'\": 'b'}"
def test___hash__():
"""test hash function for Attribute."""
A = Attribute("label", [1, "string", True])
B = Attribute("", [])
assert type(hash(B._key())) == int
assert type(hash(A._key())) == int
def test___repr__():
""" Test repr()."""
from vivid.classes.interval import Interval
a = Attribute("label", ["1", Interval(40, 50), True, 4.0, 6L])
print a.__repr__()
assert a.__repr__() == "\"label: {4.0,6,1,True,I(40, 50)}\""
