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)
