def test_eq_2(): t1 = AnnotatedText("hello word") t2 = AnnotatedText("hello word") t1.annotate(0, 5, "Hello") t1.annotate(6, 10, "world") t2.annotate(6, 10, "world") t2.annotate(0, 5, "Hello") assert t1 == t2
def test_join_by(self): t1 = AnnotatedText("I {likes=>like:::error_type=SVA} turtles.") t2 = AnnotatedText("I{,=>:::error_type=Punct} like turtles.") actual = AnnotatedText.join("\n", [t1, t2]) expected = AnnotatedText("I {likes=>like:::error_type=SVA} turtles.\n" "I{,=>:::error_type=Punct} like turtles.") assert expected == actual
def test_wrong_constructor_params(): # Constructing AnnotatedText from anything other than string is forbidden with pytest.raises(ValueError): AnnotatedText(42) annotated = AnnotatedText("hello") with pytest.raises(ValueError): AnnotatedText(annotated)
def test_parse_colon(self): text = AnnotatedText("text {.=>::::key=R:PUNCT}") expected = AnnotatedText("text .") expected.annotate(5, 6, ":", meta={"key": "R:PUNCT"}) ann = text.get_annotations()[0] expected_ann = expected.get_annotations()[0] assert ann.meta == expected_ann.meta assert ann.suggestions == expected_ann.suggestions assert ann.source_text == expected_ann.source_text
def iter_documents(self): for meta in self._get_metadata(): filename = f"{meta.doc_id}.a{self.annotator_id}.ann" path = self._data_dir / meta.partition / "annotated" / filename text = AnnotatedText(path.read_text()) doc = Document(text, meta=meta) yield doc
def test_to_str(self): text = AnnotatedText("helo world") text.annotate(0, 4, ["hello", "hola"], meta={"key": "value with spaces"}) expected = "{helo=>hello|hola:::key=value with spaces} world" assert text.get_annotated_text() == expected
def test_parse_no_suggestions(self): # When parsing text with the special "NO_SUGGESTIONS" value text = AnnotatedText("{asdasd=>NO_SUGGESTIONS}") # Then empty suggestions list should be returned ann = text.get_annotations()[0] assert ann.suggestions == []
def test_apply_correction_insert_word(): text = AnnotatedText("{=>Hello} {word=>World}!") ann = text.get_annotations()[0] # {=>Hello} text.apply_correction(ann) assert text.get_annotated_text() == "Hello {word=>World}!"
def test_apply_correction_with_no_suggestions(): # Given annotated text text = AnnotatedText("Hi {sdf=>NO_SUGGESTIONS}!") # When applyinng a no-suggestions annotation ann = text.get_annotations()[0] text.apply_correction(ann) # Then the annotation should be replaced with the original text assert text.get_annotated_text() == "Hi sdf!"
def test_apply_correction(): # Given annotated text text = AnnotatedText("{helo=>Hello}{...=>,} {word=>World}!") # When applying the corrected text of an annotation ann = text.get_annotations()[1] # {...=>,} text.apply_correction(ann) # Then annotation should be removed, and the correct text used instead assert text.get_annotated_text() == "{helo=>Hello}, {word=>World}!"
def test_remove_non_existing_annotation(): # Given annotated text text = AnnotatedText("{helo=>Hello} {word=>World}!") # When removing annotation that doesn't exists in the text # Then error should be raised annotation = text.get_annotations()[0] text.remove(annotation) with pytest.raises(ValueError): text.remove(annotation)
def test_get_annoation_at(): text = AnnotatedText("Hello {word=>world}") print(text.get_annotations()) assert text.get_annotation_at(0) is None assert text.get_annotation_at(0, 100) is None assert text.get_annotation_at(6, 10).source_text == "word" assert text.get_annotation_at(6).source_text == "word" assert text.get_annotation_at(7).source_text == "word" assert text.get_annotation_at(10) is None assert text.get_annotation_at(11) is None
def test_annotate_with_none(self): # Some checks return None in place of suggestions, meaning # that there are no good suggestions. # The convention for those in the light-annotated format is # {bad=>NO_SUGGESTIONS} annotation. text = AnnotatedText("asdasd") text.annotate(0, len("asdasd"), correct_value=None) assert text.get_annotated_text() == "{asdasd=>NO_SUGGESTIONS}" # When parsed, special value of "NO_SUGGESTIONS" should be # represented as empty suggestions list assert text.get_annotations()[0].suggestions == []
def test_parse(self): text = AnnotatedText( "Hello {wold=>World|world:::type=OOV Spell:::status=ok}") expected_original = "wold" expected_sugg = ["World", "world"] expected_meta = {"type": "OOV Spell", "status": "ok"} ann = text.get_annotations()[0] assert ann.meta == expected_meta assert ann.suggestions == expected_sugg assert ann.source_text == expected_original
def test_remove(): # Given annotated text text = AnnotatedText("{helo=>Hello} {word=>World}!") # When removing single annotation annotation = text.get_annotations()[1] assert annotation.source_text == "word" text.remove(annotation) # Then all other annotations should stay expected = "{helo=>Hello} word!" assert text.get_annotated_text() == expected assert len(text.get_annotations()) == 1
def test_iter_annotations(): # Given annotated text text = AnnotatedText("{helo=>Hello}{...=>,} {word=>World}!") # When changing annotations during annotations iteration for i, ann in enumerate(text.iter_annotations()): if i == 1: text.remove(ann) # {...=>,} else: text.apply_correction(ann) # Then the text should be correctly updated assert text.get_annotated_text() == "Hello... World!"
def test_get_annotations(): text = AnnotatedText( "this {was=>is|will be} an {anotated=>annotated} text") anns = text.get_annotations() assert len(anns) == 2 assert anns[0].source_text == "was" assert anns[0].suggestions == ["is", "will be"] assert anns[0].start == len("this ") assert anns[0].end == len("this was") assert anns[1].source_text == "anotated" assert anns[1].suggestions == ["annotated"] assert anns[1].start == len("this was an ") assert anns[1].end == len("this was an anotated")
def test_curly_braces_in_original_text(): text = AnnotatedText(r"(e.g. \emph{the, {dox=>fox}, jumps})") expected = r"(e.g. \emph{the, dox, jumps})" assert text.get_original_text() == expected
def test_error(self): text = AnnotatedText("{helllo=>Hello} {world=>World}") with pytest.raises(OverlapError): text.annotate(2, 5, "ll")
def test_repr(): text = AnnotatedText("Hello {word=>world}!") expected = "<AnnotatedText('Hello {word=>world}!')>" assert repr(text) == expected
def test_string_representation(): # AnnotatedText should pretend text = AnnotatedText("Hello {word=>world}!") expected = "Hello {word=>world}!" assert str(text) == expected
def test_not_eq_other_type(): text = "Text {=>tokens} tokens ." text_1 = AnnotatedText(text) assert text_1 != text
def test_eq(): text = "Text {=>tokens} tokens ." text_1 = AnnotatedText(text) text_2 = AnnotatedText(text) assert text_1 == text_2
def test_get_original_text(): text = AnnotatedText("{helo=>Hello} world!") expected = "helo world!" assert text.get_original_text() == expected
def test_annotate_empty_lengthy_intersect(self): text = AnnotatedText("Did n't know it.") text.annotate(12, 12, [" about"]) with pytest.raises(OverlapError): text.annotate(0, len("Did n't know it."), ["Did n't know it"])
def test_get_corrected_text_with_highlight(): text = AnnotatedText("{helo=>NO_SUGGESTIONS} world!") expected = "helo world!" assert text.get_corrected_text() == expected
def test_get_corrected_text(): text = AnnotatedText("{helo=>Hello} world!") expected = "Hello world!" assert text.get_corrected_text() == expected
def test_not_eq(): text_1 = AnnotatedText("Text {=>tokens} tokens .") text_2 = AnnotatedText("Text {=>TOKENS} tokens .") assert text_1 != text_2
def test_forbid_joining_annotation_with_multiple_suggestions(self): text = AnnotatedText("helloworld") text.annotate(0, len("helloworld"), ["hello", "hola", "hi"]) with pytest.raises(OverlapError): text.annotate(0, len("helloworld"), "world")
def test_get_annotated_text_same_span(): text = AnnotatedText("{=>b}{=>a}") assert text.get_annotated_text() == "{=>b}{=>a}"