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()