def test_couplet(self):
self.print_string('test_couplet')
elements = [
None,
bool(2),
int(2),
float(2),
complex('1+2j'),
str(2),
bytes(2),
range(-1, 5),
frozenset([None, bool(2), int(2), float(2), complex('1+2j'), str(2), bytes(2),
range(-1, 5), frozenset([None, None]), tuple((34, 35)), Atom(int(2)),
Couplet(-1, -2), Set('x', 'y', 'z')
]),
frozenset([Couplet(0, 1), Couplet(2, 3)]),
frozenset([Set('a', 'b', 'c'), Set([1, 2, 3])]),
tuple((34, 35)),
Atom(33),
Couplet(0, 'abc'),
Set(frozenset([None, 'xyz'])),
]
couplets = [Couplet(s, c) for s in elements for c in elements]
self.verify_string_import_export(couplets)
self.verify_file_import_export(couplets)
def test_diagonal(self):
base_set = Set(Atom(1))
diag_rels = [relations.diag(*base_set), relations.diag(1)]
for diag_rel in diag_rels:
self.assertEqual(diag_rel.cardinality, 1)
self.assertTrue(relations.is_member(diag_rel))
self.assertTrue(diag_rel.has_element(Couplet(1, 1)))
base_set = Set(Atom(1), Atom('a'))
diag_clan = clans.diag(1, 'a')
self.assertEqual(diag_clan.cardinality, 1)
diag_rels = [
relations.diag(*base_set),
relations.diag(1, 'a'),
sets.single(diag_clan)
]
for diag_rel in diag_rels:
self.assertEqual(diag_rel.cardinality, 2)
self.assertTrue(relations.is_member(diag_rel))
self.assertTrue(diag_rel.has_element(Couplet(1, 1)))
self.assertTrue(diag_rel.has_element(Couplet('a', 'a')))
arg1 = Set(1, 2, 3)
arg2 = [v for v in Set(1, 2, 3)]
result_diag = Set(Couplet(1, 1), Couplet(2, 2), Couplet(3, 3))
self.assertEqual(relations.diag(*arg1), result_diag)
self.assertEqual(relations.diag(*arg2), result_diag)
def test_equivalence_relation(self):
self.assertTrue(is_equivalence_relation(Set()))
self.assertFalse(is_equivalence_relation(
Set([Couplet(s, c) for c, s in zip('aba', 'bcc')])))
self.assertIs(is_equivalence_relation(Set('a', 'b', 'c')), Undef())
self.assertFalse(is_equivalence_relation(
Set([Couplet(s, c) for c, s in zip('aba', 'bcd')])))
f = is_equivalence_relation(basic_sets['left func'])
self.assertFalse(f)
f = is_equivalence_relation(basic_sets['not left func'])
self.assertFalse(f)
f = is_equivalence_relation(basic_sets['diagonal'])
self.assertTrue(f)
f = is_equivalence_relation(basic_clans['not left func'])
self.assertFalse(f)
f = is_equivalence_relation(basic_clans['diagonal'])
self.assertTrue(f)
f = is_equivalence_relation(basic_hordes['not left func'])
self.assertFalse(f)
f = is_equivalence_relation(basic_hordes['diagonal'])
self.assertTrue(f)
s = basic_sets['diagonal']
self.assertEqual(s.cached_reflexive, CacheStatus.IS)
self.assertEqual(s.cached_symmetric, CacheStatus.IS)
self.assertEqual(s.cached_transitive, CacheStatus.IS)
def test_project(self):
"""Basic tests of multiclans.project()."""
self.assertIs(project(Undef(), Undef()), Undef())
c1 = ac['clan1']
self.assertIs(project(c1, Undef()), Undef())
c2 = Multiset(Set(Couplet('a', 1)), Set(Couplet('a', 4)))
self.assertEqual(project(c1, 'a'), c2)
def test_power_up(self):
# self._check_argument_types_unary_undef(power_up)
self.assertIs(power_up(Undef()), Undef())
s1 = Set(1, 2, 3)
s2 = Set(Set(1), Set(2), Set(3))
self.assertEqual(s2, power_up(s1))
def test_membership(self):
self.assertTrue(is_member(Set()))
self.assertTrue(is_member(Set(3)))
self.assertFalse(is_member(Atom(3)))
self.assertTrue(is_absolute_member(Set(3)))
self.assertFalse(is_absolute_member(Set(Couplet(3, 4))))
self.assertRaises(AttributeError, lambda: is_member(3))
def test_project(self):
clan = basic_clans['left func']
if self.print_examples:
ss = clan.get_left_set()
pc = _convert_clan_to_list_of_dicts(ss, clan)
print(clan)
print(ss)
print(pc)
csv = io.StringIO()
export_csv(clan, csv)
csv_str = csv.getvalue()
self.assertEqual(csv_str, "a,b,c\r\n1,2,3\r\n")
if self.print_examples:
# \r doesn't print well in the (PyCharm?) console
csv_str_pr = 'csv:\n' + csv_str.replace('\r\n', '\n')
print(csv_str_pr)
clan = Set(
Set([Couplet(s, c)
for s, c in zip('abcd', [1, 2, 3, "foo, bar"])]))
csv = io.StringIO()
export_csv(clan, csv)
csv_str = csv.getvalue()
self.assertEqual(csv_str, """a,b,c,d\r\n1,2,3,"foo, bar"\r\n""")
def test_bijection(self):
self.assertTrue(is_bijective(Set()))
self.assertIs(is_bijective(Set('a', 'b', 'c')), Undef())
f = is_bijective(basic_sets['left func'])
self.assertTrue(f)
f = is_bijective(basic_sets['not left func'])
self.assertFalse(f)
f = is_bijective(basic_sets['not right func'])
self.assertFalse(f)
f = is_bijective(basic_clans['left func'])
self.assertTrue(f)
f = is_bijective(basic_clans['not right func'])
self.assertFalse(f)
f = is_bijective(basic_hordes['left func'])
self.assertTrue(f)
f = is_bijective(basic_hordes['not right func'])
self.assertFalse(f)
s = basic_sets['left func']
self.assertEqual(s.cached_functional, CacheStatus.IS)
self.assertEqual(s.cached_right_functional, CacheStatus.IS)
s = basic_sets['not left func']
self.assertEqual(s.cached_functional, CacheStatus.IS_NOT)
# The right flags aren't checked if left fails
self.assertEqual(s.cached_right_functional, CacheStatus.UNKNOWN)
def test_lhs_cross_functional_union(self):
"""Test for functional_cross_union."""
table_a = import_csv(self._get_table_a())
table_b = import_csv(self._get_table_b())
self.assertTrue(is_functional(table_a))
self.assertTrue(is_functional(table_b))
# Calculate left join.
result = lhs_cross_functional_union(table_a, table_b)
# Test result set properties
self.assertEqual(result.cached_functional, CacheStatus.IS)
self.assertFalse(result.is_empty)
self.assertEqual(result.cardinality, 8)
expected = import_csv(self._get_result_cross_functional_union())
self.assertEqual(result, expected)
import algebraixlib.algebras.sets as sets
table_aa = sets.union(table_a, Set(Set(Couplet('PK', '-1'), Couplet('PK', '-2'))))
self.assertFalse(is_functional(table_aa))
result = lhs_cross_functional_union(table_aa, table_b)
self.assertNotEqual(result.cached_functional, CacheStatus.IS)
table_bb = sets.union(table_b, Set(Set(Couplet('PK', '-1'), Couplet('PK', '-2'))))
self.assertFalse(is_functional(table_bb))
result = lhs_cross_functional_union(table_a, table_bb)
self.assertEqual(result.cached_functional, CacheStatus.IS)
def test_diag(self):
rel1 = Set(Couplet('a', 'a'), Couplet('b', 'b'))
self.assertEqual(diag('a', 'b'), rel1)
self.assertEqual(diag(), Set())
self.assertIs(diag(Undef()), Undef())
self.assertIs(diag(Undef(), _checked=False), Undef())
def test_power_set(self):
# self._check_argument_types_unary_undef(power_set)
self.assertIs(power_set(Undef()), Undef())
s1 = Set(1, 2, 3)
p1 = Set(Set(), Set(1), Set(2), Set(3), Set(1, 2), Set(1, 3), Set(2, 3), Set(1, 2, 3))
self.assertEqual(p1, power_set(s1))
def test_transitive(self):
self.assertTrue(is_transitive(Set()))
self.assertTrue(is_transitive(Set()))
self.assertTrue(is_transitive(Set([Couplet(s, c) for c, s in zip('aba', 'bcc')])))
self.assertIs(is_transitive(Set('a', 'b', 'c')), Undef())
rel = Set(Couplet(s, c) for c, s in zip('aba', 'bcd'))
self.assertFalse(is_transitive(rel))
self.assertEqual(rel.cached_transitive, CacheStatus.IS_NOT)
f = is_transitive(basic_sets['left func'])
self.assertTrue(f)
f = is_transitive(basic_sets['not left func'])
self.assertTrue(f)
f = is_transitive(basic_sets['diagonal'])
self.assertTrue(f)
f = is_transitive(basic_clans['not left func'])
self.assertTrue(f)
f = is_transitive(basic_clans['diagonal'])
self.assertTrue(f)
f = is_transitive(basic_hordes['not left func'])
self.assertTrue(f)
f = is_transitive(basic_hordes['diagonal'])
self.assertTrue(f)
s = basic_sets['left func']
self.assertEqual(s.cached_transitive, CacheStatus.IS)
def test_xml2(self):
"""Test filled with multiple attributes and a text node"""
xml_text = """<?xml version="1.0" encoding="utf-8"?>
<Root>
<record>
<field name="Country or Area">
<key>USA</key>
United States
</field>
</record>
</Root>
"""
xml_set = import_xml(io.StringIO(xml_text))
expected = \
Set(Couplet('Root',
Set(Couplet('record',
Set(Couplet('field',
Set(
Couplet('$', 'United States'),
Couplet('key', 'USA'),
Couplet('name', 'Country or Area')
)
))
))
))
self.assertEqual(xml_set, expected)
def test_simple_operations(self):
result = union(_multiset1, _multiset2)
self.assertEqual(result, Multiset(_collections.Counter("badog")))
result = add(_multiset1, _multiset2)
self.assertEqual(result, _multiset3)
result = intersect(_multiset1, _multiset2)
self.assertEqual(result, Multiset(_collections.Counter("d")))
result = minus(_multiset_magic, _multiset1)
self.assertEqual(result, Multiset(_collections.Counter("racaabra")))
p1 = Multiset(_collections.Counter("aaa"))
p2 = Multiset(_collections.Counter("bbb"))
p3 = Multiset(_collections.Counter("ccc"))
combined = Set({p1, p2, p3})
result = big_union(combined)
self.assertEqual(result, Multiset(_collections.Counter("abc" * 3)))
result = big_intersect(
Set({
_multiset_magic,
Multiset(_collections.Counter("abc" * 3)),
Multiset("a", "a", "b", "c")
}))
self.assertEqual(result, Multiset(_collections.Counter("aabc")))
def test_intersect(self):
self._check_wrong_argument_types_binary(intersect)
result = intersect(_set1, _set2)
self.assertEqual(result, _set1i2)
a_c_0 = Set(Set('a'), Set('c'), Set())
ci = _extension.binary_extend(_ab_c, _ac_a, intersect)
self.assertEqual(ci, a_c_0)
def _check_wrong_argument_types_binary(self, operation):
self.assertRaises(AttributeError, lambda: operation(3, Set(Couplet(1, 2))))
self.assertRaises(AttributeError, lambda: operation(Set(Couplet(1, 2)), 4))
self.assertIs(operation(Set(Couplet(1, 2)), Atom(4)), Undef())
self.assertIs(operation(Atom(3), Set(Couplet(1, 2))), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Couplet(1, 2), Couplet(3, 4)))
RaiseOnUndef.reset()
def test_functional_add(self):
rel1 = Set(Couplet('a', 1))
couplet = Couplet('b', 1)
rel2 = Set(Couplet('a', 1), Couplet('b', 1))
self.assertEqual(functional_add(rel1, couplet), rel2)
self.assertIs(functional_add(rel1, Undef()), Undef())
self.assertIs(functional_add(Undef(), couplet), Undef())
def test_is_transitive(self):
"""Basic tests of relations.is_transitive()."""
self.assertRaises(AttributeError, lambda: is_transitive(3))
self.assertIs(is_transitive(Atom(3)), Undef())
self.assertIs(is_transitive(Undef()), Undef())
self.assertIs(is_transitive(Undef(), _checked=False), Undef())
self.assertTrue(is_transitive(Set(Couplet('a', 'b'), Couplet('b', 'c'), Couplet('a', 'c'))))
self.assertFalse(is_transitive(Set(Couplet('a', 'b'), Couplet('b', 'c'))))
def test_demultify(self):
letters = [l for l in "abracadabra"]
self.assertIs(demultify(Set(letters)), Undef())
set1 = demultify(Multiset(letters))
self.assertTrue(isinstance(set1, Set))
self.assertEqual(set1.cardinality, 5) # set only unique letters
letters = [l for l in "abrcd"]
self.assertEqual(set1, Set(letters))
def test_diag(self):
"""Basic tests of multiclans.diag()."""
clan1 = Multiset(Set(Couplet('a'), Couplet('b')))
self.assertEqual(diag('a', 'b'), clan1)
self.assertEqual(diag(), Multiset(Set()))
self.assertIs(diag(Undef()), Undef())
self.assertIs(diag(Undef(), _checked=False), Undef())
def test_union(self):
self._check_wrong_argument_types_binary(union)
result = union(_set1, _set2)
self.assertEqual(result, _set1u2)
abc_ab_ac = Set(Set('a', 'b', 'c'), Set('a', 'b'), Set('a', 'c'))
cu = _extension.binary_extend(_ab_c, _ac_a, union)
self.assertEqual(cu, abc_ab_ac)
def test_binary_extend_errors(self):
self.assertRaises(AttributeError,
lambda: extension.binary_extend(1, 2, sets.union))
self.assertRaises(
AttributeError,
lambda: extension.binary_extend(Set(1), 2, sets.union))
self.assertRaises(
AttributeError,
lambda: extension.binary_extend(1, Set(2), sets.union))
def test_membership(self):
self.assertTrue(is_member(Multiset(Set(Couplet(1, 2)))))
self.assertFalse(is_member(Multiset(Couplet(3, 4))))
self.assertTrue(is_absolute_member(Multiset(Set(Couplet(1, 2)))))
self.assertFalse(
is_absolute_member(Multiset(Set(Couplet(Set(2, 3), 4)))))
self.assertFalse(is_absolute_member(Set(2, 3)))
# noinspection PyTypeChecker
self.assertRaises(AttributeError, lambda: is_member(3))
def test_fill_lefts(self):
rel1 = Set(Couplet('a', 1), Couplet('b', 2))
rel2 = Set(Couplet('x', 'y'))
exp = Set(Couplet('a'), Couplet('b'), Couplet('x', 'y'))
self.assertEqual(fill_lefts(rel1, rel2), exp)
self.assertIs(fill_lefts(rel1, Undef()), Undef())
self.assertIs(fill_lefts(rel1, Undef(), _checked=False), Undef())
self.assertIs(fill_lefts(Undef(), rel2), Undef())
self.assertIs(fill_lefts(Undef(), rel2, _checked=False), Undef())
def test_defined_at(self):
clan1 = Set(Set(Couplet('a', 1)))
self.assertEqual(defined_at(clan1, 'a'), clan1)
self.assertIs(defined_at(clan1, 'b'), Undef())
self.assertIs(defined_at(clan1, Undef()), Undef())
self.assertIs(defined_at(Undef(), 'a'), Undef())
self.assertRaises(AssertionError, lambda: defined_at(clan1, 'a', _checked=False))
self.assertIs(defined_at(Undef(), Atom('a'), _checked=False), Undef())
self.assertEqual(defined_at(clan1, Atom('a'), _checked=False), clan1)
def aggregate(horde, group_left, aggregation_left, aggregate_func):
aggregation = {}
for clan in horde:
aggregation_value = aggregate_func.identity
for relation in clan:
aggregation_value = aggregate_func(aggregation_value,
relation(aggregation_left).value)
first_relation = next(iter(clan))
aggregation[first_relation(group_left)] = aggregation_value
return Set([Set(Couplet(group_left, key),
Couplet(aggregation_left, aggregation[key])) for key in aggregation])
def test_join_quaternary(self):
clan1 = Set(Set([Couplet(1, 'one')]))
clan2 = Set(Set([Couplet(2, 'two')]))
clan3 = Set(Set([Couplet(3, 'three')]))
clan4 = Set(Set([Couplet(4, 'four')]))
answer = Set(
Set(Couplet(1, 'one'), Couplet(2, 'two'), Couplet(3, 'three'),
Couplet(4, 'four')))
joined = join(clan1, clan2, clan3, clan4)
# data is unordered so don't use equality, use symmetric difference
self.assertEqual(0, len(answer.data ^ joined.data))
def test_get_rights_for_left(self):
"""Basic tests of relations.get_rights_for_left()."""
rel1 = Set(Couplet('a', 1), Couplet('a', 2), Couplet('b', 3))
result = Set(1, 2)
self.assertEqual(result, get_rights_for_left(rel1, 'a'))
self.assertEqual(Set(), get_rights_for_left(rel1, Undef()))
self.assertEqual(Set(), get_rights_for_left(rel1, Undef(), _checked=False))
self.assertIs(get_rights_for_left(Undef(), 'a'), Undef())
self.assertRaises(AssertionError, lambda: get_rights_for_left(Undef(), 'a', _checked=False))
self.assertIs(get_rights_for_left(Undef(), Atom('a'), _checked=False), Undef())
def test_restrict(self):
self.assertIs(restrict(Undef(), Undef()), Undef())
s1 = Set(1, 2, 3)
self.assertRaises(TypeError, lambda: restrict(s1, Undef()))
self.assertRaises(TypeError, lambda: restrict(s1, 1))
self.assertRaises(TypeError, lambda: restrict(s1, 'a'))
self.assertEqual(restrict(s1, lambda x: x.value < 3), Set(1, 2))
self.assertEqual(restrict(s1, lambda x: x.value > 1), Set(2, 3))
def _check_wrong_argument_types_unary(self, operation):
"""Negative tests for set algebra unary operations."""
self.assertIs(operation(Atom(3)), Undef())
self.assertIs(operation(Set(Atom(3))), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Atom(3)))
RaiseOnUndef.set_level(2)
self.assertRaises(UndefException, lambda: operation(Set(Atom(3))))
RaiseOnUndef.reset()
self._check_argument_types_unary_undef(operation)
