def test_run(self): clauses = u""" SUSPENDISSE: diam SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus CONSECTETUER: elit, sed MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM DF1, 11 LOREM, 1N SUSPENDISSE LOREM: ipsum, dolor, sit TORTOR, 0N RISUS, 11 DIGNISSIM, 1N CONSECTETUER: nec DIGNISSIM: ligula, massa, varius DF, 11 RISUS, 0N RISUS AMET, 11> LOREM, 01 CONSECTETUER: adipiscing RISUS: ultricies, _cras, elementum SEMPER, 0N RISUS, 1N DIGNISSIM """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) params["crossover_rate"] = 0.9 params["max_generations"] = 50 params["mutation_rate"] = 0.06 params["plateau"] = 30 params["population_size"] = 100 params["sample_size"] = 7 params["timeout"] = None params["verbose"] = False seed(1) expected = u""" RISUS: ultricies, _cras, elementum SEMPER, 0N RISUS, 1N DIGNISSIM DIGNISSIM: ligula, massa, varius MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM TORTOR, 0N RISUS, 11 DIGNISSIM, 1N CONSECTETUER: nec CONSECTETUER: elit, sed SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus DF, 11 RISUS, 0N RISUS AMET, 11> LOREM, 01 CONSECTETUER: adipiscing LOREM: ipsum, dolor, sit DF1, 11 LOREM, 1N SUSPENDISSE SUSPENDISSE: diam """.strip().replace(" ", "") rearrangement = arrange(**params) self.assertEquals(rearrangement, { 'distances': 4.640986324787455, 'crossings': 1, 'layout': [10, 11, 7, 3, 6, 2, 1, 8, 9, 5, 4, 0] }) result = mcd.get_clauses_from_layout(**rearrangement) self.assertEquals(expected, result)
def test_arrows_are_ignored(self): clauses = u""" Personne: Num. SS, Nom, Prénom, Sexe Engendrer, 0N< Personne, 22> Personne """ t = Relations(Mcd(clauses.split("\n"), params), params) d1 = json.loads(t.get_text(json_template)) clauses = u""" Personne: Num. SS, Nom, Prénom, Sexe Engendrer, 0N Personne, 22 Personne """ t = Relations(Mcd(clauses.split("\n"), params), params) d2 = json.loads(t.get_text(json_template)) self.assertEqual(d1, d2)
def test_annotations(self): clauses = u""" Personne: Num. SS, Nom, Prénom, Sexe Engendrer, 0N [parent] Personne, 0N [enfant] Personne """ text = u""" Personne (_Num. SS_, Nom, Prénom, Sexe) Engendrer (_#Num. SS parent_, _#Num. SS enfant_) """.strip().replace(" ", "") t = Relations(Mcd(clauses.split("\n"), params), params) self.assertEqual(t.get_text(minimal_template), text) d = json.loads(t.get_text(json_template)) self.assertEqual(d["relations"][0]["this_relation_name"], u"Personne") self.assertEqual(d["relations"][0]["columns"][0]["leg_annotation"], None) self.assertEqual(d["relations"][0]["columns"][0]["label"], u"Num. SS") self.assertEqual(d["relations"][0]["columns"][1]["leg_annotation"], None) self.assertEqual(d["relations"][0]["columns"][1]["label"], u"Nom") self.assertEqual(d["relations"][0]["columns"][2]["leg_annotation"], None) self.assertEqual(d["relations"][0]["columns"][2]["label"], u"Prénom") self.assertEqual(d["relations"][0]["columns"][3]["leg_annotation"], None) self.assertEqual(d["relations"][0]["columns"][3]["label"], u"Sexe") self.assertEqual(d["relations"][1]["this_relation_name"], u"Engendrer") self.assertEqual(d["relations"][1]["columns"][0]["leg_annotation"], u"parent") self.assertEqual(d["relations"][1]["columns"][0]["label"], u"Num. SS parent") self.assertEqual(d["relations"][1]["columns"][1]["leg_annotation"], u"enfant") self.assertEqual(d["relations"][1]["columns"][1]["label"], u"Num. SS enfant")
def test_annotations_with_numbers_only_disambiguation_strategy(self): clauses = u""" Personne: Num. SS, Nom, Prénom, Sexe Engendrer, 0N [Une personne peut avoir un nombre quelconque d'enfants.] Personne, 0N [Une personne peut avoir un nombre quelconque de parents dans la base.\\nRemarque : vous avez peut-être envie de remplacer la cardinalité maximale N par sa valeur réelle, à savoir 2. Cette précision disparaissant lors du passage au relationnel, elle est en général jugée inutile.] Personne """ text = u""" Personne (_Num. SS_, Nom, Prénom, Sexe) Engendrer (_#Num. SS_, _#Num. SS.1_) """.strip().replace(" ", "") local_params = deepcopy(params) local_params["disambiguation"] = "numbers_only" t = Relations(Mcd(clauses.split("\n"), local_params), local_params) self.assertEqual(t.get_text(minimal_template), text) d = json.loads(t.get_text(json_template)) self.assertEqual(d["relations"][0]["this_relation_name"], u"Personne") self.assertEqual(d["relations"][0]["columns"][0]["leg_annotation"], None) self.assertEqual(d["relations"][0]["columns"][0]["label"], u"Num. SS") self.assertEqual(d["relations"][0]["columns"][1]["leg_annotation"], None) self.assertEqual(d["relations"][0]["columns"][1]["label"], u"Nom") self.assertEqual(d["relations"][0]["columns"][2]["leg_annotation"], None) self.assertEqual(d["relations"][0]["columns"][2]["label"], u"Prénom") self.assertEqual(d["relations"][0]["columns"][3]["leg_annotation"], None) self.assertEqual(d["relations"][0]["columns"][3]["label"], u"Sexe") self.assertEqual(d["relations"][1]["this_relation_name"], u"Engendrer") self.assertEqual(d["relations"][1]["columns"][0]["leg_annotation"], u"Une personne peut avoir un nombre quelconque d\\'enfants.") self.assertEqual(d["relations"][1]["columns"][0]["label"], u"Num. SS") self.assertEqual(d["relations"][1]["columns"][1]["leg_annotation"], u"Une personne peut avoir un nombre quelconque de parents dans la base.\nRemarque : vous avez peut-être envie de remplacer la cardinalité maximale N par sa valeur réelle, à savoir 2. Cette précision disparaissant lors du passage au relationnel, elle est en général jugée inutile.") self.assertEqual(d["relations"][1]["columns"][1]["label"], u"Num. SS.1")
def test_demoted_foreign_key(self): clauses = u""" LACUS: blandit, elit LIGULA, 0N LACUS, 1N /EROS, 0N TELLUS: metus EROS: congue, nibh, tincidunt TELLUS: integer, odio """ text = u""" LACUS (_blandit_, elit) LIGULA (_#blandit_, #congue, _#integer_, metus) EROS (_congue_, nibh, tincidunt) TELLUS (_integer_, odio) """.strip().replace(" ", "") t = Relations(Mcd(clauses.split("\n"), params), params) self.assertEqual(t.get_text(minimal_template), text) d = json.loads(t.get_text(json_template)) self.assertEqual(d["relations"][1]["this_relation_name"], u"LIGULA") self.assertEqual(d["relations"][1]["columns"][0]["nature"], u"foreign_primary_key") self.assertEqual(d["relations"][1]["columns"][0]["primary_relation_name"], u"LACUS") self.assertEqual(d["relations"][1]["columns"][1]["nature"], u"demoted_foreign_key") self.assertEqual(d["relations"][1]["columns"][1]["primary_relation_name"], u"EROS") self.assertEqual(d["relations"][1]["columns"][2]["nature"], u"foreign_primary_key") self.assertEqual(d["relations"][1]["columns"][2]["primary_relation_name"], u"TELLUS") self.assertEqual(d["relations"][1]["columns"][3]["nature"], u"association_attribute") self.assertEqual(d["relations"][1]["columns"][3]["primary_relation_name"], None)
def test_weak_entities_strengthened_by_itself(self): clauses = u""" SCELERISQUE: blandit, elit DF, _11 SCELERISQUE, 1N SCELERISQUE """ mcd = Mcd(clauses.split("\n"), params) self.assertRaisesRegex(MocodoError, "Mocodo Err\.16", Relations, mcd, params)
def test_reflexive_df(self): clauses = u""" HOMME: Num. SS, Nom, Prénom ENGENDRER, 0N HOMME, 11 HOMME """ text = u""" HOMME (_Num. SS_, Nom, Prénom, #Num. SS.1) """.strip().replace(" ", "") t = Relations(Mcd(clauses.split("\n"), params), params) self.assertEqual(t.get_text(minimal_template), text) d = json.loads(t.get_text(json_template)) self.assertEqual(d["relations"][0]["columns"][3]["foreign"], True) self.assertEqual(d["relations"][0]["columns"][3]["data_type"], None) self.assertEqual(d["relations"][0]["columns"][3]["nature"], u"foreign_key") self.assertEqual(d["relations"][0]["columns"][3]["attribute"], u"Num. SS") self.assertEqual(d["relations"][0]["columns"][3]["primary"], False) self.assertEqual(d["relations"][0]["columns"][3]["label"], u"Num. SS.1") self.assertEqual(d["relations"][0]["columns"][3]["raw_label"], u"Num. SS") self.assertEqual(d["relations"][0]["columns"][3]["association_name"], u"ENGENDRER") self.assertEqual( d["relations"][0]["columns"][3]["disambiguation_number"], 1) self.assertEqual( d["relations"][0]["columns"][3]["primary_relation_name"], u"HOMME") self.assertEqual(d["title"], u"Untitled")
def test_weak_entities_strengthened_by_several_entities(self): clauses = u""" Baby: Soon Yard, _11 Unit, ON Baby: Hall : Unit: Folk, Peer Item: Norm, Wash Ever, _11 Unit, 1N Item: Tour """ # the actual order of the result depends on Python's version possible_text_1 = u""" Baby (_Soon_) Unit (_#Norm_, _#Soon_, _Folk_, Peer, Hall, Tour) Item (_Norm_, Wash) """.strip().replace(" ", "") possible_text_2 = u""" Baby (_Soon_) Unit (_#Soon_, _#Norm_, _Folk_, Peer, Tour, Hall) Item (_Norm_, Wash) """.strip().replace(" ", "") t = Relations(Mcd(clauses.split("\n"), params), params) self.assertTrue(t.get_text(minimal_template) in (possible_text_1, possible_text_2))
def test_2_0_link(self): clauses = u""" CLIENT: Réf. client, Nom, Prénom, Adresse PASSER, 0N CLIENT, 11 COMMANDE : COMMANDE: Num commande, Date, Montant """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) d = mcd.get_layout_data() evaluate = fitness(d["links"], d["col_count"], d["row_count"]) size = d["col_count"] * d["row_count"] (crossing_count, total_distances) = evaluate(range(size)) self.assertEquals(crossing_count, 0) self.assertEquals(total_distances, 1.0)
def test_optimal_layout(self): clauses = u""" SCELERISQUE LOREM: blandit, elit, ligula EROS, 11 SCELERISQUE LOREM, 1N PELLENTESQUE IPSUM: metus, congue NIBH, 1N SCELERISQUE LOREM, 11 PELLENTESQUE IPSUM PELLENTESQUE IPSUM: tincidunt, bibendum, consequat, integer """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) d = mcd.get_layout_data() evaluate = fitness(d["links"], d["col_count"], d["row_count"]) size = d["col_count"] * d["row_count"] (crossing_count, total_distances) = evaluate(range(size)) self.assertEquals(crossing_count, 0) self.assertEquals(total_distances, 0.0)
def test_2_0_link(self): clauses = u""" CLIENT: Réf. client, Nom, Prénom, Adresse PASSER, 0N CLIENT, 11 COMMANDE : COMMANDE: Num commande, Date, Montant """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) d = mcd.get_layout_data() evaluate = fitness(d["links"], d["multiplicity"], d["col_count"], d["row_count"]) size = d["col_count"] * d["row_count"] (crossing_count, total_distances) = evaluate(list(range(size))) self.assertEqual(crossing_count, 0) self.assertEqual(total_distances, 1.0)
def test_no_links(self): clauses = u""" SUSPENDISSE: diam CONSECTETUER: elit, sed LOREM: ipsum, dolor, sit DIGNISSIM: ligula, massa, varius RISUS: ultricies, _cras, elementum """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) params["organic"] = False params["call_limit"] = 10000 params["max_objective"] = 15 params["min_objective"] = 0 params["timeout"] = None params["verbose"] = False seed(1) expected = u""" : CONSECTETUER: elit, sed : LOREM: ipsum, dolor, sit : ::: DIGNISSIM: ligula, massa, varius : : RISUS: ultricies, _cras, elementum : SUSPENDISSE: diam : """.strip().replace(" ", "") rearrangement = arrange(**params) self.assertEquals(rearrangement, { 'distances': 0.0, 'layout': [1, 2, 5, 3, 4, 0], 'crossings': 0, }) result = mcd.get_clauses_from_layout(**rearrangement) self.assertEquals(expected, result)
def test_diagonal_reflexive_association(self): clauses = u""" Norm : Draw, Unit, Folk, Peer, Tour, Hall : : Baby, 1N Norm, 0N> Norm """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) d = mcd.get_layout_data() evaluate = fitness(d["links"], d["multiplicity"], d["col_count"], d["row_count"]) size = d["col_count"] * d["row_count"] (crossing_count, total_distances) = evaluate(list(range(size))) self.assertEqual(crossing_count, 0) self.assertEqual(round(total_distances, 4), 0.8284)
def test_optimal_layout(self): clauses = u""" SCELERISQUE LOREM: blandit, elit, ligula EROS, 11 SCELERISQUE LOREM, 1N PELLENTESQUE IPSUM: metus, congue NIBH, 1N SCELERISQUE LOREM, 11 PELLENTESQUE IPSUM PELLENTESQUE IPSUM: tincidunt, bibendum, consequat, integer """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) d = mcd.get_layout_data() evaluate = fitness(d["links"], d["multiplicity"], d["col_count"], d["row_count"]) size = d["col_count"] * d["row_count"] (crossing_count, total_distances) = evaluate(list(range(size))) self.assertEqual(crossing_count, 0) self.assertEqual(total_distances, 0.0)
def test_attribute_nature_complex(self): clauses = u""" Riot: clue Walk, 1N Riot, _11 Hour Hour: book Poll, 1N Cast, 1N /Hour Cast: mere Army, 1N /Busy, 01 Cast Busy: fail """ text = u""" Riot (_clue_) Hour (_#clue_, _book_) Poll (_#mere_, #clue, #book) Cast (_mere_) Army (#fail, _#mere_) Busy (_fail_) """.strip().replace(" ", "") t = Relations(Mcd(clauses.split("\n"), params), params) self.assertEqual(t.get_text(minimal_template), text) d = json.loads(t.get_text(json_template)) self.assertEqual(d["relations"][0]["this_relation_name"], u"Riot") self.assertEqual(d["relations"][0]["columns"][0]["nature"], u"primary_key") self.assertEqual(d["relations"][0]["columns"][0]["label"], u"clue") self.assertEqual(d["relations"][1]["this_relation_name"], u"Hour") self.assertEqual(d["relations"][1]["columns"][0]["nature"], u"strengthening_primary_key") self.assertEqual(d["relations"][1]["columns"][0]["label"], u"clue") self.assertEqual(d["relations"][1]["columns"][1]["nature"], u"primary_key") self.assertEqual(d["relations"][1]["columns"][1]["label"], u"book") self.assertEqual(d["relations"][2]["this_relation_name"], u"Poll") self.assertEqual(d["relations"][2]["columns"][0]["nature"], u"foreign_primary_key") self.assertEqual(d["relations"][2]["columns"][0]["label"], u"mere") self.assertEqual(d["relations"][2]["columns"][1]["nature"], u"demoted_foreign_key") self.assertEqual(d["relations"][2]["columns"][1]["label"], u"clue") self.assertEqual(d["relations"][2]["columns"][2]["nature"], u"demoted_foreign_key") self.assertEqual(d["relations"][2]["columns"][2]["label"], u"book") self.assertEqual(d["relations"][3]["this_relation_name"], u"Cast") self.assertEqual(d["relations"][3]["columns"][0]["nature"], u"primary_key") self.assertEqual(d["relations"][3]["columns"][0]["label"], u"mere") self.assertEqual(d["relations"][4]["this_relation_name"], u"Army") self.assertEqual(d["relations"][4]["columns"][0]["nature"], u"promoting_foreign_key") self.assertEqual(d["relations"][4]["columns"][0]["label"], u"fail") self.assertEqual(d["relations"][4]["columns"][1]["nature"], u"foreign_primary_key") self.assertEqual(d["relations"][4]["columns"][1]["label"], u"mere") self.assertEqual(d["relations"][5]["this_relation_name"], u"Busy") self.assertEqual(d["relations"][5]["columns"][0]["nature"], u"primary_key") self.assertEqual(d["relations"][5]["columns"][0]["label"], u"fail")
def test_k33_better(self): clauses = u""" DIGNISSIM: nec sem, nunc, vulputate RHONCUS, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT IMPERDIET: a praesent, nibh, semper SODALES, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT TINCIDUNT: faucibus, orci, cursus QUIS ENIM, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) d = mcd.get_layout_data() evaluate = fitness(d["links"], d["col_count"], d["row_count"]) size = d["col_count"] * d["row_count"] (crossing_count, total_distances) = evaluate(range(size)) self.assertEquals(crossing_count, 3)
def test_k33_better(self): clauses = u""" DIGNISSIM: nec sem, nunc, vulputate RHONCUS, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT IMPERDIET: a praesent, nibh, semper SODALES, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT TINCIDUNT: faucibus, orci, cursus QUIS ENIM, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) d = mcd.get_layout_data() evaluate = fitness(d["links"], d["multiplicity"], d["col_count"], d["row_count"]) size = d["col_count"] * d["row_count"] (crossing_count, total_distances) = evaluate(list(range(size))) self.assertEqual(crossing_count, 3)
def test_weak_entities_with_cycle(self): clauses = u""" ITEM: norm, wash, haul MILK, _11 ITEM, 1N DRAW: lady, face SOON, 1N ITEM, _11 DRAW DRAW: ever, unit, tour, fold """ mcd = Mcd(clauses.split("\n"), params) self.assertRaisesRegex(MocodoError, "Mocodo Err\.17", Relations, mcd, params)
def test_optimal_layout_with_reflexive_association(self): clauses = u""" Assistas, 01 Hci poilu, 0N Hci poilu Hci poilu: graffiti, champignon, troussa, graffiti Rayonnait, 0N Hci poilu, 0N Lappa: monobloc Brisa: souffrait Pillards, 0N Brisa, 0N Lappa, 0N Hci poilu: disions, lascar Lappa: graffiti, champignon Puni, 11 Lappa, 0N Lappa """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) d = mcd.get_layout_data() evaluate = fitness(d["links"], d["col_count"], d["row_count"]) size = d["col_count"] * d["row_count"] (crossing_count, total_distances) = evaluate(range(size)) self.assertEquals(crossing_count, 0) self.assertEquals(total_distances, 0.0)
def test_all_cardinalities_other_than_01_and_11_are_treated_as_1N(self): clauses = u""" CLIENT: Réf. client, Nom, Prénom, Adresse PASSER, XX CLIENT, N1 COMMANDE COMMANDE: Num commande, Date, Montant INCLURE, 03 COMMANDE, ?? PRODUIT: Quantité PRODUIT: Réf. produit, Libellé, Prix unitaire """ t = Relations(Mcd(clauses.split("\n"), params), params) d1 = json.loads(t.get_text(json_template)) clauses = u""" CLIENT: Réf. client, Nom, Prénom, Adresse PASSER, 1N CLIENT, 1N COMMANDE COMMANDE: Num commande, Date, Montant INCLURE, 1N COMMANDE, 1N PRODUIT: Quantité PRODUIT: Réf. produit, Libellé, Prix unitaire """ t = Relations(Mcd(clauses.split("\n"), params), params) d2 = json.loads(t.get_text(json_template)) self.assertEqual(d1, d2)
def test_optimal_layout_with_reflexive_association(self): clauses = u""" Assistas, 01 Hci poilu, 0N Hci poilu Hci poilu: graffiti, champignon, troussa, graffiti Rayonnait, 0N Hci poilu, 0N Lappa: monobloc Brisa: souffrait Pillards, 0N Brisa, 0N Lappa, 0N Hci poilu: disions, lascar Lappa: graffiti, champignon Puni, 11 Lappa, 0N Lappa """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) d = mcd.get_layout_data() evaluate = fitness(d["links"], d["multiplicity"], d["col_count"], d["row_count"]) size = d["col_count"] * d["row_count"] (crossing_count, total_distances) = evaluate(list(range(size))) self.assertEqual(crossing_count, 0) self.assertEqual(total_distances, 0.0)
def test_character_cases(self): clauses = u""" Riot: clue Into, 11 Form, 1N Riot: goat Form: land, hide Tuck, 1N Read, 1N Form: thin Read: wage """ text = u""" Riot (_clue_) Form (_land_, hide, #clue, goat) Tuck (_#wage_, _#land_, thin) Read (_wage_) """.strip().replace(" ", "") t = Relations(Mcd(clauses.split("\n"), params), params) self.assertEqual(t.get_text(minimal_template), text) d = json.loads(t.get_text(json_template)) self.assertEqual(d["title"], u"Untitled") self.assertEqual(d["title_titlecase"], u"Untitled") self.assertEqual(d["title_lowercase"], u"untitled") self.assertEqual(d["title_uppercase"], u"UNTITLED") self.assertEqual(d["relations"][0]["this_relation_name"], u"Riot") self.assertEqual(d["relations"][0]["this_relation_name_titlecase"], u"Riot") self.assertEqual(d["relations"][0]["this_relation_name_uppercase"], u"RIOT") self.assertEqual(d["relations"][0]["this_relation_name_lowercase"], u"riot") self.assertEqual(d["relations"][0]["columns"][0]["attribute"], u"clue") self.assertEqual(d["relations"][0]["columns"][0]["label"], u"clue") self.assertEqual(d["relations"][0]["columns"][0]["label_titlecase"], u"Clue") self.assertEqual(d["relations"][0]["columns"][0]["label_uppercase"], u"CLUE") self.assertEqual(d["relations"][0]["columns"][0]["label_lowercase"], u"clue") self.assertEqual(d["relations"][0]["columns"][0]["raw_label"], u"clue") self.assertEqual(d["relations"][0]["columns"][0]["raw_label_titlecase"], u"Clue") self.assertEqual(d["relations"][0]["columns"][0]["raw_label_uppercase"], u"CLUE") self.assertEqual(d["relations"][0]["columns"][0]["raw_label_lowercase"], u"clue") self.assertEqual(d["relations"][0]["columns"][0]["primary_relation_name"], None) self.assertEqual(d["relations"][0]["columns"][0]["primary_relation_name_titlecase"], None) self.assertEqual(d["relations"][0]["columns"][0]["primary_relation_name_uppercase"], None) self.assertEqual(d["relations"][0]["columns"][0]["primary_relation_name_lowercase"], None) self.assertEqual(d["relations"][0]["columns"][0]["association_name"], None) self.assertEqual(d["relations"][0]["columns"][0]["association_name_uppercase"], None) self.assertEqual(d["relations"][0]["columns"][0]["association_name_titlecase"], None) self.assertEqual(d["relations"][0]["columns"][0]["association_name_lower_case"], None) self.assertEqual(d["relations"][1]["columns"][2]["primary_relation_name"], u"Riot") self.assertEqual(d["relations"][1]["columns"][2]["primary_relation_name_titlecase"], u"Riot") self.assertEqual(d["relations"][1]["columns"][2]["primary_relation_name_uppercase"], u"RIOT") self.assertEqual(d["relations"][1]["columns"][2]["primary_relation_name_lowercase"], u"riot") self.assertEqual(d["relations"][1]["columns"][2]["association_name"], u"Into") self.assertEqual(d["relations"][1]["columns"][2]["association_name_titlecase"], u"Into") self.assertEqual(d["relations"][1]["columns"][3]["association_name_lower_case"], u"into") self.assertEqual(d["relations"][1]["columns"][2]["association_name_uppercase"], u"INTO")
def test_difference_between_attribute_raw_label_and_label_without_annotations( self): template = { "extension": None, "transform_attribute": [{ "search": " ", "replace": "_" }, { "search": "\\.", "replace": "" }], "compose_label_disambiguated_by_number": u"{label}_{disambiguation_number}", } clauses = u""" A pour mère, 01 Chien, 0N Chien Chien: num. chien, nom chien, sexe, date naissance A pour père présumé, 0N Chien, 0N Chien """ text = u""" Chien (_num_chien_, nom_chien, sexe, date_naissance, #num_chien_1) A pour père présumé (_#num_chien_, _#num_chien_1_) """.strip().replace(" ", "") t = Relations(Mcd(clauses.split("\n"), params), params) self.assertEqual(t.get_text(template), text) my_json_template = deepcopy(json_template) my_json_template.update(template) d = json.loads(t.get_text(my_json_template)) self.assertEqual(d["relations"][0]["this_relation_name"], u"Chien") self.assertEqual(d["relations"][0]["columns"][0]["attribute"], u"num. chien") self.assertEqual(d["relations"][0]["columns"][0]["raw_label"], u"num_chien") self.assertEqual(d["relations"][0]["columns"][0]["label"], u"num_chien") self.assertEqual(d["relations"][0]["columns"][4]["attribute"], u"num. chien") self.assertEqual(d["relations"][0]["columns"][4]["raw_label"], u"num_chien") self.assertEqual(d["relations"][0]["columns"][4]["label"], u"num_chien_1") self.assertEqual(d["relations"][1]["this_relation_name"], u"A pour père présumé") self.assertEqual(d["relations"][1]["columns"][1]["attribute"], u"num. chien") self.assertEqual(d["relations"][1]["columns"][1]["raw_label"], u"num_chien") self.assertEqual(d["relations"][1]["columns"][1]["label"], u"num_chien_1")
def test_composite_identifier(self): clauses = u""" GRATTE-CIEL: latitude, _longitude, nom, hauteur, année de construction """ text = u""" GRATTE-CIEL (_latitude_, _longitude_, nom, hauteur, année de construction) """.strip().replace(" ", "") t = Relations(Mcd(clauses.split("\n"), params), params) self.assertEqual(t.get_text(minimal_template), text) d = json.loads(t.get_text(json_template)) self.assertEqual(d["relations"][0]["columns"][0]["nature"], u"primary_key") self.assertEqual(d["relations"][0]["columns"][0]["label"], u"latitude") self.assertEqual(d["relations"][0]["columns"][1]["nature"], u"primary_key") self.assertEqual(d["relations"][0]["columns"][1]["label"], u"longitude")
def test_attribute_nature_simple(self): clauses = u""" Riot: clue Into, 11 Form, 1N Riot: goat Form: land, hide Tuck, 1N Read, 1N Form: thin Read: wage """ t = Relations(Mcd(clauses.split("\n"), params), params) text = u""" Riot (_clue_) Form (_land_, hide, #clue, goat) Tuck (_#wage_, _#land_, thin) Read (_wage_) """.strip().replace(" ", "") self.assertEqual(t.get_text(minimal_template), text) d = json.loads(t.get_text(json_template)) self.assertEqual(d["relations"][0]["this_relation_name"], u"Riot") self.assertEqual(d["relations"][0]["columns"][0]["nature"], u"primary_key") self.assertEqual(d["relations"][0]["columns"][0]["label"], u"clue") self.assertEqual(d["relations"][1]["this_relation_name"], u"Form") self.assertEqual(d["relations"][1]["columns"][0]["nature"], u"primary_key") self.assertEqual(d["relations"][1]["columns"][0]["label"], u"land") self.assertEqual(d["relations"][1]["columns"][1]["nature"], u"normal_attribute") self.assertEqual(d["relations"][1]["columns"][1]["label"], u"hide") self.assertEqual(d["relations"][1]["columns"][2]["nature"], u"foreign_key") self.assertEqual(d["relations"][1]["columns"][2]["label"], u"clue") self.assertEqual(d["relations"][1]["columns"][3]["nature"], u"foreign_attribute") self.assertEqual(d["relations"][1]["columns"][3]["label"], u"goat") self.assertEqual(d["relations"][2]["this_relation_name"], u"Tuck") self.assertEqual(d["relations"][2]["columns"][0]["nature"], u"foreign_primary_key") self.assertEqual(d["relations"][2]["columns"][0]["label"], u"wage") self.assertEqual(d["relations"][2]["columns"][1]["nature"], u"foreign_primary_key") self.assertEqual(d["relations"][2]["columns"][1]["label"], u"land") self.assertEqual(d["relations"][2]["columns"][2]["nature"], u"association_attribute") self.assertEqual(d["relations"][2]["columns"][2]["label"], u"thin") self.assertEqual(d["relations"][3]["this_relation_name"], u"Read") self.assertEqual(d["relations"][3]["columns"][0]["nature"], u"primary_key") self.assertEqual(d["relations"][3]["columns"][0]["label"], u"wage")
def test_data_types(self): clauses = u""" CLIENT: Réf. client [varchar(8)], Nom [varchar(20)], Adresse [varchar(40)] DF, 0N CLIENT, 11 COMMANDE COMMANDE: Num commande [tinyint(4)], Date [date], Montant [decimal(5,2) DEFAULT '0.00'] INCLURE, 1N COMMANDE, 0N PRODUIT: Quantité [tinyint(4)] PRODUIT: Réf. produit, Libellé, Prix unitaire """ text = u""" CLIENT (_Réf. client_, Nom, Adresse) COMMANDE (_Num commande_, Date, Montant, #Réf. client) INCLURE (_#Num commande_, _#Réf. produit_, Quantité) PRODUIT (_Réf. produit_, Libellé, Prix unitaire) """.strip().replace(" ", "") t = Relations(Mcd(clauses.split("\n"), params), params) self.assertEqual(t.get_text(minimal_template), text) d = json.loads(t.get_text(json_template)) self.assertEqual(d["relations"][0]["this_relation_name"], u"CLIENT") self.assertEqual(d["relations"][0]["columns"][0]["data_type"], u"varchar(8)") self.assertEqual(d["relations"][0]["columns"][0]["label"], u"Réf. client") self.assertEqual(d["relations"][0]["columns"][1]["data_type"], u"varchar(20)") self.assertEqual(d["relations"][0]["columns"][1]["label"], u"Nom") self.assertEqual(d["relations"][0]["columns"][2]["data_type"], u"varchar(40)") self.assertEqual(d["relations"][0]["columns"][2]["label"], u"Adresse") self.assertEqual(d["relations"][1]["this_relation_name"], u"COMMANDE") self.assertEqual(d["relations"][1]["columns"][0]["data_type"], u"tinyint(4)") self.assertEqual(d["relations"][1]["columns"][0]["label"], u"Num commande") self.assertEqual(d["relations"][1]["columns"][1]["data_type"], u"date") self.assertEqual(d["relations"][1]["columns"][1]["label"], u"Date") self.assertEqual(d["relations"][1]["columns"][2]["data_type"], u"decimal(5,2) DEFAULT '0.00'") self.assertEqual(d["relations"][1]["columns"][2]["label"], u"Montant") self.assertEqual(d["relations"][1]["columns"][3]["data_type"], u"varchar(8)") self.assertEqual(d["relations"][1]["columns"][3]["label"], u"Réf. client") self.assertEqual(d["relations"][2]["this_relation_name"], u"INCLURE") self.assertEqual(d["relations"][2]["columns"][0]["data_type"], u"tinyint(4)") self.assertEqual(d["relations"][2]["columns"][0]["label"], u"Num commande") self.assertEqual(d["relations"][2]["columns"][1]["data_type"], None) self.assertEqual(d["relations"][2]["columns"][1]["label"], u"Réf. produit") self.assertEqual(d["relations"][2]["columns"][2]["data_type"], u"tinyint(4)") self.assertEqual(d["relations"][2]["columns"][2]["label"], u"Quantité") self.assertEqual(d["relations"][3]["this_relation_name"], u"PRODUIT") self.assertEqual(d["relations"][3]["columns"][0]["data_type"], None) self.assertEqual(d["relations"][3]["columns"][0]["label"], u"Réf. produit") self.assertEqual(d["relations"][3]["columns"][1]["data_type"], None) self.assertEqual(d["relations"][3]["columns"][1]["label"], u"Libellé") self.assertEqual(d["relations"][3]["columns"][2]["data_type"], None) self.assertEqual(d["relations"][3]["columns"][2]["label"], u"Prix unitaire")
def test_run(self): clauses = u""" SUSPENDISSE: diam SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus CONSECTETUER: elit, sed MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM DF1, 11 LOREM, 1N SUSPENDISSE LOREM: ipsum, dolor, sit TORTOR, 0N RISUS, 11 DIGNISSIM, 1N CONSECTETUER: nec DIGNISSIM: ligula, massa, varius DF, 11 RISUS, 0N RISUS AMET, 11> LOREM, 01 CONSECTETUER: adipiscing RISUS: ultricies, _cras, elementum SEMPER, 0N RISUS, 1N DIGNISSIM """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) params["crossover_rate"] = 0.9 params["max_generations"] = 50 params["mutation_rate"] = 0.06 params["plateau"] = 30 params["population_size"] = 100 params["sample_size"] = 7 params["timeout"] = None params["verbose"] = False seed(1 if sys.version_info.major == 2 else 67) rearrangement = arrange(**params) self.assertEqual(rearrangement, { 'distances': 3.3005630797457695, 'crossings': 1, 'layout': [9, 5, 4, 0, 2, 1, 11, 8, 3, 7, 6, 10] }) expected = u""" AMET, 11> LOREM, 01 CONSECTETUER: adipiscing LOREM: ipsum, dolor, sit DF1, 11 LOREM, 1N SUSPENDISSE SUSPENDISSE: diam CONSECTETUER: elit, sed SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus SEMPER, 0N RISUS, 1N DIGNISSIM DF, 11 RISUS, 0N RISUS MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM DIGNISSIM: ligula, massa, varius TORTOR, 0N RISUS, 11 DIGNISSIM, 1N CONSECTETUER: nec RISUS: ultricies, _cras, elementum """.strip().replace(" ", "") mcd.set_layout(**rearrangement) result = mcd.get_clauses() self.assertEqual(expected, result)
def test_empty_attributes(self): clauses = u""" CLIENT: Réf. client, , , """ text = u""" CLIENT (_Réf. client_, , .1, .2) """.strip().replace(" ", "") t = Relations(Mcd(clauses.split("\n"), params), params) self.assertEqual(t.get_text(minimal_template), text) d = json.loads(t.get_text(json_template)) self.assertEqual(d["relations"][0]["columns"][1]["attribute"], u"") self.assertEqual(d["relations"][0]["columns"][1]["raw_label"], u"") self.assertEqual(d["relations"][0]["columns"][1]["label"], u"") self.assertEqual(d["relations"][0]["columns"][1]["disambiguation_number"], None) self.assertEqual(d["relations"][0]["columns"][2]["attribute"], u"") self.assertEqual(d["relations"][0]["columns"][2]["raw_label"], u"") self.assertEqual(d["relations"][0]["columns"][2]["label"], u".1") self.assertEqual(d["relations"][0]["columns"][2]["disambiguation_number"], 1)
def test_no_links(self): clauses = u""" SUSPENDISSE: diam CONSECTETUER: elit, sed LOREM: ipsum, dolor, sit DIGNISSIM: ligula, massa, varius RISUS: ultricies, _cras, elementum """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) params["organic"] = False params["call_limit"] = 10000 params["max_objective"] = 15 params["min_objective"] = 0 params["timeout"] = None params["verbose"] = False seed(1 if sys.version_info.major == 2 else 458) expected = u""" : CONSECTETUER: elit, sed : LOREM: ipsum, dolor, sit : ::: DIGNISSIM: ligula, massa, varius : : RISUS: ultricies, _cras, elementum : SUSPENDISSE: diam : """.strip().replace(" ", "") rearrangement = arrange(**params) self.assertEqual(rearrangement, { 'distances': 0.0, 'layout': [1, 2, 5, 3, 4, 0], 'crossings': 0, }) mcd.set_layout(**rearrangement) result = mcd.get_clauses() self.assertEqual(expected, result)
def test_non_connected_graph(self): clauses = u""" SUSPENDISSE: diam SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus CONSECTETUER: elit, sed MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM DF1, 11 LOREM, 1N SUSPENDISSE LOREM: ipsum, dolor, sit DIGNISSIM: ligula, massa, varius DF, 11 RISUS, 0N RISUS AMET, 11> LOREM, 01 CONSECTETUER: adipiscing RISUS: ultricies, _cras, elementum SEMPER, 0N RISUS, 1N DIGNISSIM """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) params["organic"] = False params["call_limit"] = 10000 params["max_objective"] = 15 params["min_objective"] = 0 params["timeout"] = None params["verbose"] = False seed(42 if sys.version_info.major == 2 else 129) rearrangement = arrange(**params) mcd.set_layout(**rearrangement) self.assertEqual( rearrangement, { 'distances': 0.0, 'crossings': 0, 'coords': { 0: (2, 2), 1: (2, 1), 2: (2, 0), 3: (0, 0), 4: (3, 2), 5: (3, 1), 6: (0, 1), 7: (1, 0), 8: (0, 2), 9: (3, 0), 10: (1, 2), 11: (1, 1) }, 'layout': [3, 7, 2, 9, 6, 11, 1, 5, 8, 10, 0, 4] }) expected = u""" MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM : CONSECTETUER: elit, sed AMET, 11> LOREM, 01 CONSECTETUER: adipiscing DIGNISSIM: ligula, massa, varius SEMPER, 0N RISUS, 1N DIGNISSIM SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus LOREM: ipsum, dolor, sit DF, 11 RISUS, 0N RISUS RISUS: ultricies, _cras, elementum SUSPENDISSE: diam DF1, 11 LOREM, 1N SUSPENDISSE """.strip().replace(" ", "") result = mcd.get_clauses() self.assertEqual(expected, result)
def test_non_connected_graph(self): clauses = u""" SUSPENDISSE: diam SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus CONSECTETUER: elit, sed MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM DF1, 11 LOREM, 1N SUSPENDISSE LOREM: ipsum, dolor, sit DIGNISSIM: ligula, massa, varius DF, 11 RISUS, 0N RISUS AMET, 11> LOREM, 01 CONSECTETUER: adipiscing RISUS: ultricies, _cras, elementum SEMPER, 0N RISUS, 1N DIGNISSIM """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) params["organic"] = False params["call_limit"] = 10000 params["max_objective"] = 15 params["min_objective"] = 0 params["timeout"] = None params["verbose"] = False seed(42) expected = u""" MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM : CONSECTETUER: elit, sed AMET, 11> LOREM, 01 CONSECTETUER: adipiscing DIGNISSIM: ligula, massa, varius SEMPER, 0N RISUS, 1N DIGNISSIM SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus LOREM: ipsum, dolor, sit DF, 11 RISUS, 0N RISUS RISUS: ultricies, _cras, elementum SUSPENDISSE: diam DF1, 11 LOREM, 1N SUSPENDISSE """.strip().replace(" ", "") rearrangement = arrange(**params) self.assertEquals(rearrangement, { 'distances': 0.0, 'crossings': 0, 'coords': { 0: (2, 2), 1: (2, 1), 2: (2, 0), 3: (0, 0), 4: (3, 2), 5: (3, 1), 6: (0, 1), 7: (1, 0), 8: (0, 2), 9: (3, 0), 10: (1, 2), 11: (1, 1) }, 'layout': [3, 7, 2, 9, 6, 11, 1, 5, 8, 10, 0, 4] }) result = mcd.get_clauses_from_layout(**rearrangement) self.assertEquals(expected, result)
def test_organic_rearrangement(self): clauses = u""" SUSPENDISSE: diam SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus CONSECTETUER: elit, sed MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM DF1, 11 LOREM, 1N SUSPENDISSE LOREM: ipsum, dolor, sit TORTOR, 0N RISUS, 11 DIGNISSIM, 1N CONSECTETUER: nec DIGNISSIM: ligula, massa, varius DF, 11 RISUS, 0N RISUS AMET, 11> LOREM, 01 CONSECTETUER: adipiscing RISUS: ultricies, _cras, elementum SEMPER, 0N RISUS, 1N DIGNISSIM """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) params["organic"] = True params["call_limit"] = 10000 params["max_objective"] = 15 params["min_objective"] = 0 params["timeout"] = None params["verbose"] = False seed(1) expected = u""" DF1, 11 LOREM, 1N SUSPENDISSE LOREM: ipsum, dolor, sit AMET, 11> LOREM, 01 CONSECTETUER: adipiscing : SUSPENDISSE: diam SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus CONSECTETUER: elit, sed MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM :: TORTOR, 0N RISUS, 11 DIGNISSIM, 1N CONSECTETUER: nec DIGNISSIM: ligula, massa, varius :: RISUS: ultricies, _cras, elementum SEMPER, 0N RISUS, 1N DIGNISSIM :: DF, 11 RISUS, 0N RISUS : """.strip().replace(" ", "") rearrangement = arrange(**params) self.assertEquals(rearrangement, { 'distances': 0.0, 'layout': [4, 5, 9, None, 0, 1, 2, 3, None, None, 6, 7, None, None, 10, 11, None, None, 8, None], 'crossings': 0, 'col_count': 4, 'row_count': 5, 'coords': { 0: (0, 1), 1: (1, 1), 2: (2, 1), 3: (3, 1), 4: (0, 0), 5: (1, 0), 6: (2, 2), 7: (3, 2), 8: (2, 4), 9: (2, 0), 10: (2, 3), 11: (3, 3) } }) result = mcd.get_clauses_from_layout(**rearrangement) self.assertEquals(expected, result)
def test_reciprocical_relative_entities(self): clauses = u""" Aids: Norm, Free, Soon, Pack, Face, Seem, Teen Yard, 0N Unit, ON Aids Ever, 1N Unit, 1N Item Item: Norm, Wash, Haul, Milk, Draw, Lady, Face, Soon, Dish : Amid, 1n Aids, 1n Disk, _11 Flip: Gold Same, _11 Unit, 0N Flip Unit: Folk, Peer, Tour, Hall Fold, _11 Unit, 1N Baby, _11 Item Baby: Soon Disk: Soon, Ride, Folk, Call, Gear, Tent, Lean Flip: Lend Pump, _11 Flip, 1N Unit: Both, Raid Gene: Soon Bind, _11 Baby, 1n Gene """ mcd = Mcd(clauses.split("\n"), params) self.assertRaisesRegex(MocodoError, "Mocodo Err\.22", Relations, mcd, params) clauses = u""" Disk: Soon, Ride, Folk, Call, Gear, Tent, Lean Flip: Lend Pump, _11 Flip, 1N Unit: Both, Raid Gene: Soon Bind, _11 Baby, 1n Gene Amid, 1n Aids, 1n Disk, _11 Flip: Gold Same, _11 Unit, 0N Flip Unit: Folk, Peer, Tour, Hall Fold, _11 Unit, 1N Baby, _11 Item Baby: Soon Aids: Norm, Free, Soon, Pack, Face, Seem, Teen Yard, 0N Unit, ON Aids Ever, 1N Unit, 1N Item Item: Norm, Wash, Haul, Milk, Draw, Lady, Face, Soon, Dish : """ mcd = Mcd(clauses.split("\n"), params) self.assertRaisesRegex(MocodoError, "Mocodo Err\.22", Relations, mcd, params) mcd = Mcd(clauses.split("\n"), params) self.assertRaisesRegex(MocodoError, "Mocodo Err\.22", Relations, mcd, params) clauses = u""" ITEM, 1N NORM, 1N WASH NORM: haul WASH: soon BABY, 1N WASH, 1N FACE FACE: gene AAA, _11 FLIP, 1N WASH FLIP: soona GEAR, _11 FLIP, _11 FACE """ mcd = Mcd(clauses.split("\n"), params) self.assertRaisesRegex(MocodoError, "Mocodo Err\.22", Relations, mcd, params) clauses = u""" ITEM, 1N NORM, 1N WASH NORM: haul WASH: soon BABY, 1N WASH, 1N FACE FACE: gene CCC, _11 FLIP, 1N WASH FLIP: soona GEAR, _11 FLIP, _11 FACE """ mcd = Mcd(clauses.split("\n"), params) self.assertRaisesRegex(MocodoError, "Mocodo Err\.22", Relations, mcd, params)
def test_weak_entities(self): clauses = u""" Rue: code rue, nom rue Se situer, 0N Rue, _11 Immeuble Immeuble: num immeuble, nb étages immeuble Appartenir, 1N Immeuble, _11 Étage Étage: num étage, nb appart. étage Composer, 0N Étage, _11 Appartement Appartement: num appart., nb pièces appart. """ text = u""" Rue (_code rue_, nom rue) Immeuble (_#code rue_, _num immeuble_, nb étages immeuble) Étage (_#code rue_, _#num immeuble_, _num étage_, nb appart. étage) Appartement (_#code rue_, _#num immeuble_, _#num étage_, _num appart._, nb pièces appart.) """.strip().replace(" ", "") t = Relations(Mcd(clauses.split("\n"), params), params) self.assertEqual(t.get_text(minimal_template), text) d = json.loads(t.get_text(json_template)) self.assertEqual(d["relations"][3]["this_relation_name"], u"Appartement") self.assertEqual(d["relations"][3]["columns"][0]["attribute"], u"code rue") self.assertEqual(d["relations"][3]["columns"][0]["label"], u"code rue") self.assertEqual(d["relations"][3]["columns"][0]["raw_label"], u"code rue") self.assertEqual(d["relations"][3]["columns"][0]["foreign"], True) self.assertEqual(d["relations"][3]["columns"][0]["primary"], True) self.assertEqual(d["relations"][3]["columns"][0]["nature"], u"strengthening_primary_key") self.assertEqual(d["relations"][3]["columns"][0]["association_name"], u"Composer") self.assertEqual(d["relations"][3]["columns"][0]["primary_relation_name"], u"Étage") self.assertEqual(d["relations"][3]["columns"][1]["attribute"], u"num immeuble") self.assertEqual(d["relations"][3]["columns"][1]["label"], u"num immeuble") self.assertEqual(d["relations"][3]["columns"][1]["raw_label"], u"num immeuble") self.assertEqual(d["relations"][3]["columns"][1]["foreign"], True) self.assertEqual(d["relations"][3]["columns"][1]["primary"], True) self.assertEqual(d["relations"][3]["columns"][1]["nature"], u"strengthening_primary_key") self.assertEqual(d["relations"][3]["columns"][1]["association_name"], u"Composer") self.assertEqual(d["relations"][3]["columns"][1]["primary_relation_name"], u"Étage") self.assertEqual(d["relations"][3]["columns"][2]["attribute"], u"num étage") self.assertEqual(d["relations"][3]["columns"][2]["label"], u"num étage") self.assertEqual(d["relations"][3]["columns"][2]["raw_label"], u"num étage") self.assertEqual(d["relations"][3]["columns"][2]["foreign"], True) self.assertEqual(d["relations"][3]["columns"][2]["primary"], True) self.assertEqual(d["relations"][3]["columns"][2]["nature"], u"strengthening_primary_key") self.assertEqual(d["relations"][3]["columns"][2]["association_name"], u"Composer") self.assertEqual(d["relations"][3]["columns"][2]["primary_relation_name"], u"Étage") self.assertEqual(d["relations"][3]["columns"][3]["attribute"], u"num appart.") self.assertEqual(d["relations"][3]["columns"][3]["label"], u"num appart.") self.assertEqual(d["relations"][3]["columns"][3]["raw_label"], u"num appart.") self.assertEqual(d["relations"][3]["columns"][3]["foreign"], False) self.assertEqual(d["relations"][3]["columns"][3]["primary"], True) self.assertEqual(d["relations"][3]["columns"][3]["nature"], u"primary_key") self.assertEqual(d["relations"][3]["columns"][3]["association_name"], None) self.assertEqual(d["relations"][3]["columns"][3]["primary_relation_name"], None) self.assertEqual(d["relations"][3]["columns"][4]["attribute"], u"nb pièces appart.") self.assertEqual(d["relations"][3]["columns"][4]["label"], u"nb pièces appart.") self.assertEqual(d["relations"][3]["columns"][4]["raw_label"], u"nb pièces appart.") self.assertEqual(d["relations"][3]["columns"][4]["foreign"], False) self.assertEqual(d["relations"][3]["columns"][4]["primary"], False) self.assertEqual(d["relations"][3]["columns"][4]["nature"], u"normal_attribute") self.assertEqual(d["relations"][3]["columns"][4]["association_name"], None) self.assertEqual(d["relations"][3]["columns"][4]["primary_relation_name"], None) self.assertEqual(d["title"], u"Untitled")
SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus CONSECTETUER: elit, sed MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM DF1, 11 LOREM, 1N SUSPENDISSE LOREM: ipsum, dolor, sit TORTOR, 0N RISUS, 11 DIGNISSIM, 1N CONSECTETUER: nec DIGNISSIM: ligula, massa, varius DF, 11 RISUS, 0N RISUS AMET, 11> LOREM, 01 CONSECTETUER: adipiscing RISUS: ultricies, _cras, elementum SEMPER, 0N RISUS, 1N DIGNISSIM """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) class ArrangeLP(unittest.TestCase): def test_with_cplex(self): params["engine"] = "cplex" rearrangement = arrange(**params) mcd.set_layout(**rearrangement) result = mcd.get_clauses() self.assertEqual(rearrangement["crossings"], 0) self.assertEqual(round(rearrangement["distances"], 4), 0.8284) self.assertEqual(rearrangement["layout"], [11, 3, 0, 4, 10, 7, 1, 5, 8, 6, 2, 9]) self.assertEqual( result, u"""
def test_organic_rearrangement(self): clauses = u""" SUSPENDISSE: diam SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus CONSECTETUER: elit, sed MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM DF1, 11 LOREM, 1N SUSPENDISSE LOREM: ipsum, dolor, sit TORTOR, 0N RISUS, 11 DIGNISSIM, 1N CONSECTETUER: nec DIGNISSIM: ligula, massa, varius DF, 11 RISUS, 0N RISUS AMET, 11> LOREM, 01 CONSECTETUER: adipiscing RISUS: ultricies, _cras, elementum SEMPER, 0N RISUS, 1N DIGNISSIM """.replace(" ", "") params = parsed_arguments() mcd = Mcd(clauses.split("\n"), params) params.update(mcd.get_layout_data()) params["organic"] = True params["call_limit"] = 10000 params["max_objective"] = 15 params["min_objective"] = 0 params["timeout"] = None params["verbose"] = False seed(1 if sys.version_info.major == 2 else 299) expected = u""" DF1, 11 LOREM, 1N SUSPENDISSE LOREM: ipsum, dolor, sit AMET, 11> LOREM, 01 CONSECTETUER: adipiscing : SUSPENDISSE: diam SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus CONSECTETUER: elit, sed MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM :: TORTOR, 0N RISUS, 11 DIGNISSIM, 1N CONSECTETUER: nec DIGNISSIM: ligula, massa, varius :: RISUS: ultricies, _cras, elementum SEMPER, 0N RISUS, 1N DIGNISSIM :: DF, 11 RISUS, 0N RISUS : """.strip().replace(" ", "") rearrangement = arrange(**params) self.assertEqual( rearrangement, { 'distances': 0.0, 'layout': [ 4, 5, 9, None, 0, 1, 2, 3, None, None, 6, 7, None, None, 10, 11, None, None, 8, None ], 'crossings': 0, 'col_count': 4, 'row_count': 5, 'coords': { 0: (0, 1), 1: (1, 1), 2: (2, 1), 3: (3, 1), 4: (0, 0), 5: (1, 0), 6: (2, 2), 7: (3, 2), 8: (2, 4), 9: (2, 0), 10: (2, 3), 11: (3, 3) } }) mcd.set_layout(**rearrangement) result = mcd.get_clauses() self.assertEqual(expected, result)