def test_extent_before_translation() -> None: with pytest.raises(ValueError): Text.of_iterable( [ TextLine.of_iterable(LineNumber(1), [Word.of([Reading.of_name("bu")])]), TextLine.of_iterable(LineNumber(2), [Word.of([Reading.of_name("bu")])]), TranslationLine(tuple(), "en", Extent(LineNumber(1))), ] )
def test_extent_overlapping_languages() -> None: Text.of_iterable( [ TextLine.of_iterable(LineNumber(1), [Word.of([Reading.of_name("bu")])]), TranslationLine(tuple(), "en", Extent(LineNumber(2))), TextLine.of_iterable(LineNumber(2), [Word.of([Reading.of_name("bu")])]), TranslationLine(tuple(), "de"), ] )
def test_exent_overlapping() -> None: with pytest.raises(ValueError): Text.of_iterable( [ TextLine.of_iterable(LineNumber(1), [Word.of([Reading.of_name("bu")])]), TranslationLine(tuple(), extent=Extent(LineNumber(2))), TextLine.of_iterable(LineNumber(2), [Word.of([Reading.of_name("bu")])]), TranslationLine(tuple()), ] )
def test_parse_ruling_dollar_line(prefix, ruling, expected_ruling, status, expected_status, status_space, parenthesis): ruling = f"{ruling} ruling" ruling_with_status = (f"{ruling} {status}" if (status and status_space) else f"{ruling}{status}") line = f"({ruling_with_status})" if parenthesis else ruling_with_status assert (parse_atf_lark(f"{prefix}{line}").lines == Text.of_iterable( [RulingDollarLine(expected_ruling, expected_status)]).lines)
def text_with_labels(): return Text.of_iterable([ TextLine.of_iterable(LineNumber(1), [Word.of([Reading.of_name("bu")])]), ColumnAtLine(ColumnLabel.from_int(1)), SurfaceAtLine(SurfaceLabel([], atf.Surface.SURFACE, "Stone wig")), ObjectAtLine(ObjectLabel([], atf.Object.OBJECT, "Stone wig")), TextLine.of_iterable(LineNumber(2), [Word.of([Reading.of_name("bu")])]), ])
def test_load_line(lines): parser_version = "2.3.1" serialized_lines = OneOfLineSchema().dump(lines, many=True) assert TextSchema().load( { "lines": serialized_lines, "parser_version": parser_version, "numberOfLines": 1, } ) == Text.of_iterable(lines).set_parser_version(parser_version)
def test_query_lemmas_ignores_in_value(parts, expected, fragment_repository, lemma_repository): fragment = FragmentFactory.build( text=Text.of_iterable([ TextLine.of_iterable( LineNumber(1), [Word.of(parts, unique_lemma=(WordId("ana I"), ))]) ]), signs="DIŠ", ) fragment_repository.create(fragment) assert lemma_repository.query_lemmas("ana", False) == expected
def test_updating_manuscripts(corpus, text_repository, bibliography, changelog, signs, sign_repository, user, when) -> None: uncertain_fragments = (MuseumNumber.of("K.1"), ) updated_chapter = attr.evolve( CHAPTER, manuscripts=(attr.evolve( CHAPTER.manuscripts[0], colophon=Transliteration.of_iterable([ TextLine.of_iterable(LineNumber(1, True), (Word.of([Reading.of_name("ba")]), )) ]), unplaced_lines=Transliteration.of_iterable([ TextLine.of_iterable(LineNumber(1, True), (Word.of([Reading.of_name("ku")]), )) ]), notes="Updated manuscript.", ), ), uncertain_fragments=uncertain_fragments, signs=("KU ABZ075 ABZ207a\\u002F207b\\u0020X\nBA\nKU", ), ) expect_find_and_update_chapter( bibliography, changelog, CHAPTER_WITHOUT_DOCUMENTS, updated_chapter, signs, sign_repository, text_repository, user, when, ) manuscripts = (updated_chapter.manuscripts[0], ) assert (corpus.update_manuscripts(CHAPTER.id_, manuscripts, uncertain_fragments, user) == updated_chapter)
class ManuscriptFactory(factory.Factory): class Meta: model = Manuscript id = factory.Sequence(lambda n: n + 1) siglum_disambiguator = factory.Faker("word") museum_number = factory.Sequence( lambda n: MuseumNumber("M", str(n)) if pydash.is_odd(n) else None ) accession = factory.Sequence(lambda n: f"A.{n}" if pydash.is_even(n) else "") period_modifier = factory.fuzzy.FuzzyChoice(PeriodModifier) period = factory.fuzzy.FuzzyChoice(set(Period) - {Period.NONE}) provenance = factory.fuzzy.FuzzyChoice(set(Provenance) - {Provenance.STANDARD_TEXT}) type = factory.fuzzy.FuzzyChoice(set(ManuscriptType) - {ManuscriptType.NONE}) notes = factory.Faker("sentence") colophon = Transliteration.of_iterable( [TextLine.of_iterable(LineNumber(1, True), (Word.of([Reading.of_name("ku")]),))] ) unplaced_lines = Transliteration.of_iterable( [TextLine.of_iterable(LineNumber(1, True), (Word.of([Reading.of_name("nu")]),))] ) references = factory.List( [factory.SubFactory(ReferenceFactory, with_document=True)], TupleFactory )
def test_parse_dividers() -> None: line, expected_tokens = ( r'1. :? :#! :# ::? :.@v /@19* :"@20@c ;@v@19!', [ TextLine.of_iterable( LineNumber(1), ( Divider.of(":", tuple(), (atf.Flag.UNCERTAIN, )), Divider.of(":", tuple(), (atf.Flag.DAMAGE, atf.Flag.CORRECTION)), Divider.of(":", tuple(), (atf.Flag.DAMAGE, )), Divider.of("::", tuple(), (atf.Flag.UNCERTAIN, )), Divider.of(":.", ("@v", ), tuple()), Divider.of("/", ("@19", ), (atf.Flag.COLLATION, )), Divider.of(':"', ("@20", "@c"), tuple()), Divider.of(";", ("@v", "@19"), (atf.Flag.CORRECTION, )), ), ) ], ) assert parse_atf_lark(line).lines == Text.of_iterable( expected_tokens).lines
def test_combinations( qualification, extent, scope, state, status, expected_qualification, expected_extent, expected_scope, expected_state, expected_status, ): line = " ".join(["$", qualification, extent, scope, state, status]) expected_line = StateDollarLine( expected_qualification, expected_extent, expected_scope, expected_state, expected_status, ) assert parse_atf_lark(line).lines == Text.of_iterable([expected_line ]).lines
def test_parse_atf_at_line(line, expected_tokens): assert parse_atf_lark(line).lines == Text.of_iterable( expected_tokens).lines
def test_parse_image_dollar_line(line, expected_line): assert parse_atf_lark(line).lines == Text.of_iterable([expected_line ]).lines
APPROXIMATE = True CLASSIFICATION = Classification.ANCIENT STAGE = Stage.NEO_BABYLONIAN VERSION = "A" CHAPTER_NAME = "IIc" ORDER = 1 MANUSCRIPT_ID = 9001 SIGLUM_DISAMBIGUATOR = "1c" MUSEUM_NUMBER = MuseumNumber("BM", "x") ACCESSION = "" PERIOD_MODIFIER = PeriodModifier.LATE PERIOD = Period.OLD_BABYLONIAN PROVENANCE = Provenance.NINEVEH TYPE = ManuscriptType.LIBRARY NOTES = "some notes" COLOPHON = Transliteration.of_iterable( [TextLine(LineNumber(1, True), (Word.of([Reading.of_name("ku")]), ))]) UNPLACED_LINES = Transliteration.of_iterable( [TextLine(LineNumber(4, True), (Word.of([Reading.of_name("bu")]), ))]) REFERENCES = (ReferenceFactory.build(), ) LINE_NUMBER = LineNumber(1) LINE_RECONSTRUCTION = (AkkadianWord.of((ValueToken.of("buāru"), )), ) IS_SECOND_LINE_OF_PARALLELISM = True IS_BEGINNING_OF_SECTION = True LABELS = (SurfaceLabel.from_label(Surface.OBVERSE), ) PARATEXT = (NoteLine((StringPart("note"), )), RulingDollarLine(Ruling.SINGLE)) OMITTED_WORDS = (1, ) NOTE = None PARALLEL_LINES = (ParallelComposition(False, "a composition", LineNumber(7)), ) TRANSLATION = (TranslationLine((StringPart("foo"), ), "en", None), ) SIGNS = ("FOO BAR", )
def test_translation_berofe_text() -> None: with pytest.raises(ValueError): Text.of_iterable([TranslationLine(tuple()), *LINES])
def test_extent(extent, expected_extent): line = f"$ {extent}" expected_line = StateDollarLine(None, expected_extent, None, None, None) assert parse_atf_lark(line).lines == Text.of_iterable([expected_line ]).lines
def test_scope(scope, expected_scope): line = f"$ {scope}" expected_line = StateDollarLine(None, None, expected_scope, None, None) assert parse_atf_lark(line).lines == Text.of_iterable([expected_line ]).lines
def test_qualification(qualification, expected_qualification): line = f"$ {qualification}" expected_line = StateDollarLine(expected_qualification, None, None, None, None) assert parse_atf_lark(line).lines == Text.of_iterable([expected_line ]).lines
from ebl.transliteration.domain.text_line import TextLine from ebl.transliteration.domain.tokens import Joiner, ValueToken, Variant from ebl.transliteration.domain.word_tokens import Word @pytest.mark.parametrize( # pyre-ignore[56] "old,new,expected", [ ( Text.of_iterable([ TextLine.of_iterable( LineNumber(1), [ Word.of([ Reading.of_name("ha"), Joiner.hyphen(), Reading.of_name("am"), ]) ], ), ControlLine("#", " comment"), ]), Text.of_iterable([ TextLine.of_iterable( LineNumber(1), [ Word.of([ Reading.of_name("ha"), Joiner.hyphen(), Reading.of_name("am"), ])
def test_parse_state_dollar_line_surface_ambiguity(line, expected_line): assert parse_atf_lark(line).lines == Text.of_iterable([expected_line ]).lines
def test_of_iterable() -> None: assert Text.of_iterable(LINES) == Text(LINES, atf.ATF_PARSER_VERSION)
def test_parse_text_line(line: str, expected_tokens: List[Line]) -> None: assert parse_atf_lark(line).lines == Text.of_iterable( expected_tokens).lines
def test_parse_state_dollar_line(prefix, parenthesis, line, expected_line): atf_ = f"{prefix}({line})" if parenthesis else f"{prefix}{line}" assert parse_atf_lark(atf_).lines == Text.of_iterable([expected_line ]).lines
def test_status(status, expected_status): line = f"$ {status}" expected_line = StateDollarLine(None, None, None, None, expected_status) assert parse_atf_lark(line).lines == Text.of_iterable([expected_line ]).lines
def test_parse_note_line() -> None: markup = "this is a note @i{italic text}@akk{kur}@sux{kur}" atf = f"#note: {markup}" expected_line = NoteLine(parse_markup(markup)) assert parse_atf_lark(atf).lines == Text.of_iterable([expected_line]).lines
def test_egpytian_feet_metrical_feet_line(line: str, expected_tokens: List[Line]) -> None: assert parse_atf_lark(line).lines == Text.of_iterable( expected_tokens).lines