class TestConjugatePresent(unittest.TestCase):
def setUp(self) -> None:
self.present_conjugate = PresentConjugateNormalization(None)
self.empty_input = Inputs()
def test_nothing(self):
generated_fact = GeneratedFact("test", "adapt", "nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.present_conjugate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("adapt", generated_facts[0].get_predicate().get())
def test_s(self):
generated_fact = GeneratedFact("test", "adapts", "nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.present_conjugate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("adapt", generated_facts[0].get_predicate().get())
def test_false_s(self):
generated_fact = GeneratedFact("test", "pass", "nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.present_conjugate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("pass", generated_facts[0].get_predicate().get())
class TestSimpleWikipediaCooccurrence(unittest.TestCase):
def setUp(self) -> None:
self.simple_wikipedia_no_cache = SimpleWikipediaCooccurrenceSubmodule(None, False)
self.empty_input = Inputs()
def test_lion(self):
generated_fact = GeneratedFact("lion", "is a", "cat", "", False, MultipleScore(), MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.simple_wikipedia_no_cache.process(inputs)
self.assertEqual(1, len(inputs.get_generated_facts()))
scores = inputs.get_generated_facts()[0].get_score()
scores_wikipedia = [x for x in scores.scores if x[2].get_name() == "Simple Wikipedia Cooccurrence"]
self.assertEqual(1, len(scores_wikipedia))
self.assertTrue(scores_wikipedia[0][0] != 0)
def test_cache(self):
wikipedia_cache = SimpleWikipediaCooccurrenceSubmodule(None, True, "simple-wikipedia-cache-test")
generated_fact = GeneratedFact("lion", "is a", "cat", "", False, MultipleScore(), MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
wikipedia_cache.process(inputs)
generated_fact = GeneratedFact("lion", "is a", "cat", "", False, MultipleScore(), MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = wikipedia_cache.process(inputs)
self.assertEqual(1, len(inputs.get_generated_facts()))
scores = inputs.get_generated_facts()[0].get_score()
scores_wikipedia = [x for x in scores.scores if x[2].get_name() == "Simple Wikipedia Cooccurrence"]
self.assertEqual(1, len(scores_wikipedia))
self.assertTrue(scores_wikipedia[0][0] != 0)
wikipedia_cache.cache.delete_cache()
class TestPresentContinuous(unittest.TestCase):
def setUp(self) -> None:
self.present_continuous = PresentContinuousSubmodule(None)
self.empty_input = Inputs()
def test_nothing(self):
generated_fact = GeneratedFact("test", "adapt", "nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.present_continuous.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("adapt", generated_facts[0].get_predicate().get())
def test_be_ing(self):
generated_fact = GeneratedFact("test", "is adapting", "nothing",
MultipleSourceOccurrence(), False, 0.0,
"")
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.present_continuous.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("adapt", generated_facts[0].get_predicate().get())
def test_ing(self):
generated_fact = GeneratedFact("test", "adapting", "nothing", "",
False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.present_continuous.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(0, len(generated_facts))
def setUp(self) -> None:
dummy_reference = ReferencableInterface("Dummy reference")
self.openie_fact_generator = OpenIEFactGeneratorSubmodule(
dummy_reference)
self.openie_fact_generator._name = "OPENIE" # Dummy name only useful for testing
self.empty_input = Inputs()
self.basic_modality = BasicModalitySubmodule(None)
def setUp(self) -> None:
dummy_reference = ReferencableInterface("Dummy reference")
self.openie_fact_generator = OpenIEFactGeneratorSubmodule(
dummy_reference)
self.openie_fact_generator._name = "OPENIE" # Dummy name only useful for testing
self.empty_input = Inputs()
self.are_transformation = AreTransformationSubmodule(None)
class TestToSingular(unittest.TestCase):
def setUp(self) -> None:
self.to_singular = ToSingularSubjectSubmodule(None)
self.empty_input = Inputs()
def test_turn_singular(self):
generated_fact = GeneratedFact("lions", "is a", "cat", "", False,
MultipleScore(),
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts(
[generated_fact]).add_subjects({Subject("lion")})
inputs = self.to_singular.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("lion", generated_facts[0].get_subject().get())
def test_turn_singular_duplicate(self):
generated_fact = GeneratedFact("lions", "is a", "cat", "", False,
MultipleScore(),
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts(
[generated_fact, generated_fact]).add_subjects({Subject("lion")})
inputs = self.to_singular.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(2, len(generated_facts))
self.assertEqual("lion", generated_facts[0].get_subject().get())
def test_do_nothing(self):
generated_fact = GeneratedFact("lion", "is a", "cat", "", False,
MultipleScore(),
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts(
[generated_fact]).add_subjects({Subject("lion")})
inputs = self.to_singular.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("lion", generated_facts[0].get_subject().get())
def test_crisis(self):
generated_fact = GeneratedFact("crisis", "is a", "cat", "", False,
MultipleScore(),
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts(
[generated_fact]).add_subjects({Subject("lion")})
inputs = self.to_singular.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("crisis", generated_facts[0].get_subject().get())
def test_texas(self):
generated_fact = GeneratedFact("texas", "is a", "cat", "", False,
MultipleScore(),
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts(
[generated_fact]).add_subjects({Subject("lion")})
inputs = self.to_singular.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("texas", generated_facts[0].get_subject().get())
def setUp(self) -> None:
dummy_reference = ReferencableInterface("Dummy reference")
self.openie_fact_generator = OpenIEFactGeneratorSubmodule(
dummy_reference)
self.openie_fact_generator._name = "OPENIE" # Dummy name only useful for testing
self.empty_input = Inputs()
self.associations = ImagetagSubmodule(None)
self.associations_flick_cluster = FlickrClustersSubmodule(None)
def test_conceptual_caption(self):
sc = ConceptualCaptionsComparatorSubmodule(None)
self.empty_input = Inputs()
self.dummy_reference = ReferencableInterface("DUMMY")
dataset = [("elephant", "download", "baby", 0),
("elephant", "have", "tusks", 1),
("lion", "eat", "gazella", 0),
("penguin", "eat", "fish", 0),
("gorilla", "eat", "banana", 0),
("sky", "hasProperty", "blue", 0),
("computer", "is", "working", 1),
("raccoon", "hasProperty", "blue", 0)]
subjects = {
Subject("elephant"),
Subject("penguin"),
Subject("lion"),
Subject("gorilla"),
Subject("sky"),
Subject("computer"),
Subject("raccoon")
}
gfs = []
pos = 0
for subject, predicate, obj, truth in dataset:
pos += 1
score = MultipleScore()
if pos % 2 == 0:
score.add_score(
truth, self.dummy_reference,
GoogleAutocompleteSubmodule(self.dummy_reference))
else:
score.add_score(
truth, self.dummy_reference,
BingAutocompleteSubmodule(self.dummy_reference))
gfs.append(
GeneratedFact(subject, predicate, obj, "", False, score,
MultipleSourceOccurrence()))
score2 = MultipleScore()
score2.add_score(1, self.dummy_reference,
GoogleAutocompleteSubmodule(self.dummy_reference))
gfs.append(
GeneratedFact(
"elephant", "be", "big", "", False, score2,
MultipleSourceOccurrence.from_raw("elephants are big", None,
1)))
inputs = self.empty_input.add_generated_facts(gfs).add_subjects(
subjects)
inputs = sc.process(inputs)
self.assertEqual(len(dataset) + 1, len(inputs.get_generated_facts()))
self.assertEqual(
len(inputs.get_generated_facts()[0].get_score().scores), 2)
self.assertNotAlmostEqual(
inputs.get_generated_facts()[1].get_score().scores[1][0],
0,
delta=1e-5)
class TestGoogleBook(unittest.TestCase):
def setUp(self) -> None:
self.google_book_no_cache = GoogleBookSubmodule(None, False)
self.empty_input = Inputs()
def test_lion_eat_zebras(self):
generated_fact = GeneratedFact("lion", "eat", "zebra", "", False,
MultipleScore(),
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.google_book_no_cache.process(inputs)
self.assertEqual(1, len(inputs.get_generated_facts()))
scores = inputs.get_generated_facts()[0].get_score()
scores_google_book = [
x for x in scores.scores
if x[2].get_name() == "Google Book Submodule"
]
self.assertEqual(1, len(scores_google_book))
self.assertTrue(scores_google_book[0][0] != 0)
def test_lion_eat_code(self):
generated_fact = GeneratedFact("lion", "eat", "code", "", False,
MultipleScore(),
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.google_book_no_cache.process(inputs)
self.assertEqual(1, len(inputs.get_generated_facts()))
scores = inputs.get_generated_facts()[0].get_score()
scores_google_book = [
x for x in scores.scores
if x[2].get_name() == "Google Book Submodule"
]
self.assertEqual(1, len(scores_google_book))
self.assertTrue(scores_google_book[0][0] == 0)
def test_cache(self):
google_book_cache = GoogleBookSubmodule(
None, True, cache_name="google-book-cache-temp")
generated_fact = GeneratedFact("lion", "eat", "zebra", "", False,
MultipleScore(),
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
google_book_cache.process(inputs)
generated_fact = GeneratedFact("lion", "eat", "zebra", "", False,
MultipleScore(),
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = google_book_cache.process(inputs)
self.assertEqual(1, len(inputs.get_generated_facts()))
scores = inputs.get_generated_facts()[0].get_score()
scores_google_book = [
x for x in scores.scores
if x[2].get_name() == "Google Book Submodule"
]
self.assertEqual(1, len(scores_google_book))
self.assertTrue(scores_google_book[0][0] != 0)
google_book_cache.cache.delete_cache()
def setUp(self) -> None:
self.autocomplete = BingAutocompleteSubmodule(None,
use_cache=False,
look_new=True)
self.autocomplete_cache = BingAutocompleteSubmodule(
None,
use_cache=True,
cache_name="google-cache-test",
look_new=True)
self.empty_input = Inputs()
class TestBasicModality(unittest.TestCase):
def setUp(self) -> None:
dummy_reference = ReferencableInterface("Dummy reference")
self.openie_fact_generator = OpenIEFactGeneratorSubmodule(
dummy_reference)
self.openie_fact_generator._name = "OPENIE" # Dummy name only useful for testing
self.empty_input = Inputs()
self.basic_modality = BasicModalitySubmodule(None)
def test_always(self):
suggestion = ("why does panda always climb tree", 1.0, None, "panda")
new_gfs = self.openie_fact_generator.get_generated_facts([suggestion])
inputs = self.empty_input.add_generated_facts(new_gfs)
inputs = self.basic_modality.process(inputs)
self.assertEqual(1, len(inputs.get_generated_facts()))
self.assertEqual("panda",
inputs.get_generated_facts()[0].get_subject().get())
self.assertEqual("climb",
inputs.get_generated_facts()[0].get_predicate().get())
self.assertEqual("tree",
inputs.get_generated_facts()[0].get_object().get())
self.assertIn("always",
inputs.get_generated_facts()[0].get_modality().get())
def test_often_object(self):
suggestion = ("why do pandas climb in tree often", 1.0, None, "panda")
new_gfs = self.openie_fact_generator.get_generated_facts([suggestion])
inputs = self.empty_input.add_generated_facts(new_gfs)
inputs = self.basic_modality.process(inputs)
self.assertEqual(1, len(inputs.get_generated_facts()))
self.assertEqual("pandas",
inputs.get_generated_facts()[0].get_subject().get())
self.assertEqual("climb in",
inputs.get_generated_facts()[0].get_predicate().get())
self.assertEqual("tree",
inputs.get_generated_facts()[0].get_object().get())
self.assertIn("often",
inputs.get_generated_facts()[0].get_modality().get())
def test_with_already_one_modality(self):
suggestion = ("why do african pandas eat bananas often", 1.0, None,
"panda")
new_gfs = self.openie_fact_generator.get_generated_facts([suggestion])
inputs = self.empty_input.add_generated_facts(new_gfs)
inputs = self.basic_modality.process(inputs)
gfs = [
x for x in inputs.get_generated_facts()
if x.get_subject() == "pandas"
]
self.assertEqual(1, len(gfs))
self.assertEqual("pandas", gfs[0].get_subject().get())
self.assertEqual("eat", gfs[0].get_predicate().get())
self.assertEqual("bananas", gfs[0].get_object().get())
self.assertIn("often", gfs[0].get_modality().get())
def test_not_remove(self):
inputs = Inputs()
mso = MultipleSourceOccurrence()
mso.add_raw("elephants eat big bananas", None, 2)
gfs = [
GeneratedFact("elephant", "eat", "bananas", "TBC[big bananas]", 0,
MultipleScore(), mso)
]
inputs = inputs.add_generated_facts(gfs)
tbc_cleaner = TBCCleaner(None)
inputs = tbc_cleaner.process(inputs)
self.assertEqual(len(inputs.get_generated_facts()), 1)
class TestAssociation(unittest.TestCase):
def setUp(self) -> None:
dummy_reference = ReferencableInterface("Dummy reference")
self.openie_fact_generator = OpenIEFactGeneratorSubmodule(
dummy_reference)
self.openie_fact_generator._name = "OPENIE" # Dummy name only useful for testing
self.empty_input = Inputs()
self.associations = ImagetagSubmodule(None)
self.associations_flick_cluster = FlickrClustersSubmodule(None)
def test_panda_imagetag(self):
new_gfs = [
GeneratedFact("panda", "climb", "tree", "", False, MultipleScore(),
MultipleSourceOccurrence())
]
inputs = self.empty_input.add_generated_facts(new_gfs).add_subjects(
{"panda"})
inputs = self.associations.process(inputs)
self.assertEqual(1, len(inputs.get_generated_facts()))
scores = inputs.get_generated_facts()[0].get_score()
scores_imagetag = [
x for x in scores.scores
if x[2].get_name() == "Image Tag submodule"
]
self.assertEqual(1, len(scores_imagetag))
def test_panda_flickr_cluster(self):
new_gfs = [
GeneratedFact("panda", "live", "china", "", False, MultipleScore(),
MultipleSourceOccurrence())
]
inputs = self.empty_input.add_generated_facts(new_gfs).add_subjects(
{Subject("panda")})
inputs = self.associations_flick_cluster.process(inputs)
self.assertEqual(1, len(inputs.get_generated_facts()))
scores = inputs.get_generated_facts()[0].get_score()
scores_flickr = [
x for x in scores.scores if x[2].get_name() == "Flickr"
]
self.assertEqual(1, len(scores_flickr))
def test_panda_flickr_cluster_raw(self):
clusters = self.associations_flick_cluster._get_clusters("panda")
merge_clusters = []
for cluster in clusters:
merge_clusters += cluster
self.assertIn("china", merge_clusters)
def test_article(self):
gfs = [
GeneratedFact("bee", "make", "hive", "", False, 0.1,
MultipleSourceOccurrence()),
GeneratedFact("bee", "make", "a hive", "", False, 0.1,
MultipleSourceOccurrence())
]
inputs = Inputs()
inputs = inputs.add_generated_facts(gfs)
remover = SimilarObjectRemover(None)
inputs = remover.process(inputs)
self.assertEqual(len(inputs.get_generated_facts()), 2)
self.assertEqual(
len(
set([
x.get_object().get() for x in inputs.get_generated_facts()
])), 1)
class TestCanTransformation(unittest.TestCase):
def setUp(self) -> None:
self.can_transformation = CanTransformationSubmodule(None)
self.empty_input = Inputs()
def test_can_duplicate(self):
generated_fact = GeneratedFact("test", "can", "can nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.can_transformation.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("can", generated_facts[0].get_predicate().get())
self.assertEqual("nothing", generated_facts[0].get_object().get())
def test_can_be_duplicate(self):
generated_fact = GeneratedFact("test", "can", "can be nothing", "",
False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.can_transformation.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("can be", generated_facts[0].get_predicate().get())
self.assertEqual("nothing", generated_facts[0].get_object().get())
def test_be_can_duplicate(self):
generated_fact = GeneratedFact("test", "be", "can nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.can_transformation.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("be", generated_facts[0].get_predicate().get())
self.assertEqual("nothing", generated_facts[0].get_object().get())
def test_be_can_duplicate_pattern(self):
generated_fact = GeneratedFact("test", "be", "can nothing", "", False,
0.0, MultipleSourceOccurrence(),
PatternGoogle("why can <SUBJ>"))
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.can_transformation.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("can be", generated_facts[0].get_predicate().get())
self.assertEqual("nothing", generated_facts[0].get_object().get())
def test_get_content(self):
sc = ConceptualCaptionsComparatorSubmodule(None)
self.empty_input = Inputs()
subjects = {
Subject("elephant"),
Subject("penguin"),
Subject("lion"),
Subject("raccoon")
}
inputs = self.empty_input.add_subjects(subjects)
sc.setup_processing(inputs)
contents = sc.get_contents("elephant")
self.assertEqual(3748, len(contents))
contents = sc.get_contents("penguin")
self.assertEqual(1273, len(contents))
contents = sc.get_contents("lion")
self.assertEqual(2616, len(contents))
contents = sc.get_contents("raccoon")
self.assertEqual(365, len(contents))
class TestFilterObject(unittest.TestCase):
def setUp(self) -> None:
self.cleaning_predicate = FilterObjectSubmodule(None)
self.empty_input = Inputs()
def test_forbidden(self):
generated_fact = GeneratedFact("test", "is", "used", "", False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(0, len(generated_facts))
def test_totally_forbidden(self):
generated_fact = GeneratedFact("test", "is", "useful minecraft", "", False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(0, len(generated_facts))
def test_one_letter(self):
generated_fact = GeneratedFact("test", "is", "a", "", False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(0, len(generated_facts))
def test_dirty(self):
generated_fact = GeneratedFact("test", "is", "their time", "", False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("time", generated_facts[0].get_object().get())
def test_no_change(self):
generated_fact = GeneratedFact("test", "is", "time", "", False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("time", generated_facts[0].get_object().get())
class TestIdenticalSubjectObject(unittest.TestCase):
def setUp(self) -> None:
self.identical = IdenticalSubjectObjectSubmodule(None)
self.empty_input = Inputs()
def test_removal(self):
new_gfs = [
GeneratedFact("lion", "eat", "lion", "some", False, None,
MultipleSourceOccurrence())
]
inputs = self.empty_input.replace_generated_facts(new_gfs)
inputs = self.identical.process(inputs)
self.assertEqual(0, len(inputs.get_generated_facts()))
def process(self, input_interface):
logging.info("Start the Pattern Generation module")
new_inputs = []
for submodule in self._submodules:
new_inputs.append(submodule.process(input_interface))
new_patterns = input_interface.get_patterns()
for inputs in new_inputs:
new_patterns += inputs.get_patterns()
return Inputs(input_interface.get_seeds(),
new_patterns,
input_interface.get_generated_facts(),
input_interface.get_subjects(),
input_interface.get_objects())
class TestQuora(unittest.TestCase):
def setUp(self) -> None:
self.quora = QuoraQuestionsSubmodule(None)
self.empty_input = Inputs()
def test_elephant(self):
inputs = self.empty_input.add_subjects({Subject("elephant")})
inputs = self.quora.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertIn("elephant", generated_facts[0].get_subject().get())
self.assertTrue(generated_facts[0].is_negative())
class TestToSingular(unittest.TestCase):
def setUp(self) -> None:
self.to_lower_case = ToLowerCaseSubmodule(None)
self.empty_input = Inputs()
def test_subject(self):
generated_fact = GeneratedFact("Lions", "is a", "cat", "", False, MultipleScore(), MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact]).add_subjects({Subject("lion")})
inputs = self.to_lower_case.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("lions", generated_facts[0].get_subject().get())
def test_predicate(self):
generated_fact = GeneratedFact("lions", "is A", "cat", "", False, MultipleScore(), MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact, generated_fact]).add_subjects({Subject("lion")})
inputs = self.to_lower_case.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(2, len(generated_facts))
self.assertEqual("is a", generated_facts[0].get_predicate().get())
def test_object(self):
generated_fact = GeneratedFact("lion", "is a", "cAt", "", False, MultipleScore(), MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact]).add_subjects({Subject("lion")})
inputs = self.to_lower_case.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("cat", generated_facts[0].get_object().get())
def test_do_nothing(self):
generated_fact = GeneratedFact("crisis", "is a", "cat", "", False, MultipleScore(), MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact]).add_subjects({Subject("lion")})
inputs = self.to_lower_case.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("crisis", generated_facts[0].get_subject().get())
class TestLinearWeightedCombination(unittest.TestCase):
def setUp(self) -> None:
self.dummy_reference = ReferencableInterface("Dummy reference")
self.linear_combination = LinearCombinationWeightedSubmodule(
self.dummy_reference)
self.empty_input = Inputs()
def test_combination(self):
dataset = [("elephant", "download", "baby", 0),
("elephant", "climb", "trunk", 0),
("elephant", "bear", "baby", 1),
("elephant", "download this cute illustration with", "baby",
0), ("elephant", "be", "ear", 0),
("elephant", "fry", "ear", 0),
("elephant", "trek", "travel", 0),
("elephant", "forbid love in", "water", 0),
("elephant", "eat", "bark", 1),
("elephant", "have", "tusks", 1)]
gfs = []
pos = 0
for subject, predicate, obj, truth in dataset:
pos += 1
score = MultipleScore()
if pos % 2 == 0:
score.add_score(
truth, self.dummy_reference,
GoogleAutocompleteSubmodule(self.dummy_reference))
else:
score.add_score(
truth, self.dummy_reference,
BingAutocompleteSubmodule(self.dummy_reference))
gfs.append(
GeneratedFact(subject, predicate, obj, "", False, score,
MultipleSourceOccurrence()))
score2 = MultipleScore()
score2.add_score(1, self.dummy_reference,
GoogleAutocompleteSubmodule(self.dummy_reference))
gfs.append(
GeneratedFact(
"elephant", "be", "big", "", False, score2,
MultipleSourceOccurrence.from_raw("elephants are big", None,
1)))
inputs = self.empty_input.add_generated_facts(gfs)
inputs = self.linear_combination.process(inputs)
self.assertEqual(len(dataset) + 1, len(inputs.get_generated_facts()))
class TestBingAutocomplete(unittest.TestCase):
def setUp(self) -> None:
self.autocomplete = BingAutocompleteSubmodule(None,
use_cache=False,
look_new=True)
self.autocomplete_cache = BingAutocompleteSubmodule(
None,
use_cache=True,
cache_name="google-cache-test",
look_new=True)
self.empty_input = Inputs()
def test_elephant(self):
suggestions, from_cache = self.autocomplete.get_suggestion(
"why are elephants")
self.assertFalse(from_cache)
self.assertEqual(len(suggestions), 8)
def test_cache(self):
_, _ = self.autocomplete_cache.get_suggestion("why are elephants")
time.sleep(10)
suggestions, from_cache = self.autocomplete_cache.get_suggestion(
"why are elephants")
self.assertTrue(from_cache)
self.assertEqual(len(suggestions), 8)
self.autocomplete_cache.cache.delete_cache()
def _test_process(self):
inputs = self.empty_input.add_subjects([
Subject("elephant")
]).add_patterns([PatternGoogle("why are <SUBJS>")])
inputs = self.autocomplete.process(inputs)
self.assertTrue(len(inputs.get_generated_facts()) > 16)
trunk_facts = [
x for x in inputs.get_generated_facts()
if "trunk" in x.get_object().get()
]
self.assertTrue(len(trunk_facts) > 0)
def generate_input(self):
# just give an empty input to the seed module
empty_input = Inputs()
return empty_input.add_subjects({Subject("elephant")})
subject = second_collection_element
else:
pattern = second_collection_element
subject = first_collection_element
# Generate the query
base_query = pattern.to_str_subject(subject)
base_sentences = []
# Artificially add more suggestions
to_process = [[]]
yield base_query + " "
# Generate inputs
default_module_factory = DefaultModuleFactory()
seeds = default_module_factory.get_module("all-seeds")
inputs = Inputs([], [], [], [], [])
inputs = seeds.process(inputs)
patterns = default_module_factory.get_module("patterns")
inputs = patterns.process(inputs)
# Get query generator
query_generator = get_all_queries(inputs)
query_queue = Queue()
for query in query_generator:
query_queue.put(query)
# Start Server
app = Flask(__name__)
def setUp(self) -> None:
self.cleaning_predicate = CleaningPredicateSubmodule(None)
self.empty_input = Inputs()
class TestCleaningPredicate(unittest.TestCase):
def setUp(self) -> None:
self.cleaning_predicate = CleaningPredicateSubmodule(None)
self.empty_input = Inputs()
def test_so(self):
generated_fact = GeneratedFact("test", "is so", "nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("is", generated_facts[0].get_predicate().get())
def test_xbox(self):
generated_fact = GeneratedFact("test", "xbox", "nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(0, len(generated_facts))
def test_no_change(self):
generated_fact = GeneratedFact("test", "is", "nothing", "", False, 0.0,
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("is", generated_facts[0].get_predicate().get())
def test_no_verb(self):
generated_fact = GeneratedFact("test", "table", "nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
print(generated_facts)
self.assertEqual(0, len(generated_facts))
def test_no_verb2(self):
generated_fact = GeneratedFact("wall", "clock", "yellow", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
print(generated_facts)
self.assertEqual(0, len(generated_facts))
def test_conjugated_verb(self):
generated_fact = GeneratedFact("elephant", "going", "nowhere", "",
False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
def test_conjugated_verb2(self):
generated_fact = GeneratedFact("elephant", "go", "nowhere", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
def test_conjugated_verb3(self):
generated_fact = GeneratedFact("elephant", "goes", "nowhere", "",
False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
def test_not_digest(self):
generated_fact = GeneratedFact("elephant", "not digests", "fruits", "",
False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual(generated_facts[0].get_predicate().get(), "digests")
self.assertTrue(generated_facts[0].is_negative())
def test_empty_predicate(self):
generated_fact = GeneratedFact("elephant", "", "fruits", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(0, len(generated_facts))
def test_has_beach(self):
generated_fact = GeneratedFact("beach", "has", "sand", "", False, 0.0,
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.cleaning_predicate.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
class TestBeNormalization(unittest.TestCase):
def setUp(self) -> None:
self.be_normalization = BeNormalizationSubmodule(None)
self.empty_input = Inputs()
def test_is_alone(self):
generated_fact = GeneratedFact("test", "is", "nothing", "", False, 0.0,
MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.be_normalization.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("be", generated_facts[0].get_predicate().get())
def test_are_alone(self):
generated_fact = GeneratedFact("test", "are", "nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.be_normalization.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("be", generated_facts[0].get_predicate().get())
def test_were_alone(self):
generated_fact = GeneratedFact("test", "were", "nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.be_normalization.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("was", generated_facts[0].get_predicate().get())
def test_is_not_alone(self):
generated_fact = GeneratedFact("test", "is adapted", "nothing", "",
False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.be_normalization.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("be adapted",
generated_facts[0].get_predicate().get())
def test_are_not_alone(self):
generated_fact = GeneratedFact("test", "are adapted", "nothing", "",
False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.be_normalization.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("be adapted",
generated_facts[0].get_predicate().get())
def test_were_not_alone(self):
generated_fact = GeneratedFact("test", "were adapted", "nothing", "",
False, 0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.be_normalization.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("was adapted",
generated_facts[0].get_predicate().get())
def test_no_change(self):
generated_fact = GeneratedFact("test", "adapted", "nothing", "", False,
0.0, MultipleSourceOccurrence())
inputs = self.empty_input.add_generated_facts([generated_fact])
inputs = self.be_normalization.process(inputs)
generated_facts = inputs.get_generated_facts()
self.assertEqual(1, len(generated_facts))
self.assertEqual("adapted", generated_facts[0].get_predicate().get())
def setUp(self) -> None:
self.be_normalization = BeNormalizationSubmodule(None)
self.empty_input = Inputs()
def setUp(self) -> None:
self.simple_wikipedia_no_cache = SimpleWikipediaCooccurrenceSubmodule(None, False)
self.empty_input = Inputs()
