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)