def test_parse_atf_at_line_duplicate_status_error(): with pytest.raises(TransliterationError) as exc_info: parse_atf_lark("@column 1!!") assert exc_info.value.errors == [{ "description": "Duplicate Status", "lineNumber": 1 }]
def test_split_lines(atf, expected): lines = parse_atf_lark(atf).lines splitted_lines = tuple( line for line in [lines[:expected[0]], lines[expected[1]:]] if len(line)) assert split_lines(lines) == splitted_lines
def test_create_empty(sign_repository): factory = TransliterationUpdateFactory(sign_repository) atf = Atf("") assert factory.create(atf, "") == TransliterationUpdate(parse_atf_lark(atf), "", "")
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 test_validate_invalid_value(): with pytest.raises(TransliterationError, match="Invalid transliteration") as excinfo: TransliterationUpdate(parse_atf_lark("1. x"), signs="? ?") assert excinfo.value.errors == [{ "description": "Invalid value", "lineNumber": 1 }]
def test_create(sign_repository, signs): for sign in signs: sign_repository.create(sign) factory = TransliterationUpdateFactory(sign_repository) atf = Atf("1. šu gid₂") notes = "notes" assert factory.create(atf, notes) == TransliterationUpdate( parse_atf_lark(atf), notes, "ŠU BU")
def test_update_transliteration_with_record(fragment_repository, user): fragment = FragmentFactory.build() fragment_repository.create(fragment) updated_fragment = fragment.update_transliteration( TransliterationUpdate(parse_atf_lark("$ (the transliteration)"), "notes"), user ) fragment_repository.update_transliteration(updated_fragment) result = fragment_repository.query_by_museum_number(fragment.number) assert result == updated_fragment
def test_update_update_transliteration_not_found( fragment_updater, user, fragment_repository, when ): number = "unknown.number" (when(fragment_repository).query_by_museum_number(number).thenRaise(NotFoundError)) with pytest.raises(NotFoundError): fragment_updater.update_transliteration( number, TransliterationUpdate(parse_atf_lark("$ (the transliteration)"), "notes"), user, )
def test_add_lowest_join_transliteration(user): fragment = FragmentFactory.build( number=MuseumNumber.of("X.2"), joins=Joins([[Join(MuseumNumber.of("X.1"), is_in_fragmentarium=True)]]), ) atf = Atf("1. x x") text = parse_atf_lark(atf) transliteration = TransliterationUpdate(text, fragment.notes) with pytest.raises(NotLowestJoinError): fragment.update_lowest_join_transliteration(transliteration, user)
def test_update_transliteration( number, ignore_lowest_join, fragment_updater, user, fragment_repository, changelog, parallel_line_injector, when, ): transliterated_fragment = TransliteratedFragmentFactory.build( number=number, joins=Joins([[Join(MuseumNumber.of("X.1"), is_in_fragmentarium=True)]]), line_to_vec=None, ) number = transliterated_fragment.number atf = Atf("1. x x\n2. x") transliteration = TransliterationUpdate( parse_atf_lark(atf), "updated notes", "X X\nX" ) transliterated_fragment = transliterated_fragment.update_transliteration( transliteration, user ) injected_fragment = transliterated_fragment.set_text( parallel_line_injector.inject_transliteration(transliterated_fragment.text) ) ( when(fragment_repository) .query_by_museum_number(number) .thenReturn(transliterated_fragment) ) when(changelog).create( "fragments", user.profile, {"_id": str(number), **SCHEMA.dump(transliterated_fragment)}, {"_id": str(number), **SCHEMA.dump(transliterated_fragment)}, ).thenReturn() ( when(fragment_repository) .update_transliteration(transliterated_fragment) .thenReturn() ) result = fragment_updater.update_transliteration( number, transliteration, user, ignore_lowest_join ) assert result == (injected_fragment, False)
def test_validate_multiple_errors(): with pytest.raises(TransliterationError, match="Invalid transliteration") as excinfo: TransliterationUpdate(parse_atf_lark("1. x\n$ (valid)\n2. x"), signs="? ?\n? ? ?") assert excinfo.value.errors == [ { "description": "Invalid value", "lineNumber": 1 }, { "description": "Invalid value", "lineNumber": 3 }, ]
def test_parse_normalized_akkadain_shift() -> None: word = "ha" line = f"1. {word} %n {word} %sux {word}" expected = Text((TextLine.of_iterable( LineNumber(1), ( Word.of((Reading.of_name(word), ), DEFAULT_LANGUAGE), LanguageShift.normalized_akkadian(), AkkadianWord.of((ValueToken.of(word), )), LanguageShift.of("%sux"), Word.of((Reading.of_name(word), ), Language.SUMERIAN), ), ), )) assert parse_atf_lark(line).lines == expected.lines
def test_add_transliteration(user): fragment = FragmentFactory.build() atf = Atf("1. x x") text = parse_atf_lark(atf) transliteration = TransliterationUpdate(text, fragment.notes) record = fragment.record.add_entry("", atf, user) updated_fragment = fragment.update_transliteration(transliteration, user) expected_fragment = attr.evolve( fragment, text=text, record=record, line_to_vec=((LineToVecEncoding.START, LineToVecEncoding.TEXT_LINE), ), ) assert updated_fragment == expected_fragment
def test_parse_atf_language_shifts(code: str, expected_language: Language) -> None: word = "ha-am" parts = [Reading.of_name("ha"), Joiner.hyphen(), Reading.of_name("am")] line = f"1. {word} {code} {word} %sb {word}" expected = Text((TextLine.of_iterable( LineNumber(1), ( Word.of(parts, DEFAULT_LANGUAGE), LanguageShift.of(code), Word.of(parts, expected_language), LanguageShift.of("%sb"), Word.of(parts, Language.AKKADIAN), ), ), )) assert parse_atf_lark(line).lines == expected.lines
def test_update_transliteration(user): lemmatized_fragment = LemmatizedFragmentFactory.build() lines = lemmatized_fragment.text.atf.split("\n") lines[1] = "2'. [...] GI₆ mu u₄-š[u ...]" atf = Atf("\n".join(lines)) text = parse_atf_lark(atf) transliteration = TransliterationUpdate(text, "updated notes", "X X\nX") updated_fragment = lemmatized_fragment.update_transliteration( transliteration, user) expected_fragment = attr.evolve( lemmatized_fragment, text=lemmatized_fragment.text.merge(text), notes=transliteration.notes, signs=transliteration.signs, record=lemmatized_fragment.record.add_entry( lemmatized_fragment.text.atf, transliteration.text.atf, user), ) assert updated_fragment == expected_fragment
def test_get_matching_lines(query, expected): transliterated_fragment = FragmentFactory.build( text=parse_atf_lark( Atf("1'. [...-ku]-nu-ši [...]\n" "\n" "@obverse\n" "2'. [...] GI₆ ana GI₆ u₄-m[a ...]\n" "3'. [... k]i-du u ba-ma-t[a ...]\n" "6'. [...] x mu ta-ma-tu₂\n" "7'. šu/gid")), signs="KU NU IGI\n" "GI₆ DIŠ GI₆ UD MA\n" "KI DU U BA MA TA\n" "X MU TA MA UD\n" "ŠU/BU", ) query = TransliterationQuery(query) lines = transliterated_fragment.get_matching_lines(query) assert lines == tuple(map(tuple, expected))
def test_update_update_transliteration_not_lowest_join( fragment_updater, user, fragment_repository, when ): number = MuseumNumber.of("X.2") transliterated_fragment = TransliteratedFragmentFactory.build( number=number, joins=Joins([[Join(MuseumNumber.of("X.1"), is_in_fragmentarium=True)]]), ) ( when(fragment_repository) .query_by_museum_number(number) .thenReturn(transliterated_fragment) ) with pytest.raises(NotLowestJoinError): fragment_updater.update_transliteration( number, TransliterationUpdate(parse_atf_lark("1. x"), "updated notes", "X"), user, False, )
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_update_transliteration(client, fragmentarium, user, database): fragment = FragmentFactory.build() fragmentarium.create(fragment) updates = { "transliteration": "$ (the transliteration)", "notes": "some notes" } body = json.dumps(updates) url = f"/fragments/{fragment.number}/transliteration" post_result = client.simulate_post(url, body=body) expected_json = { **create_response_dto( fragment.update_transliteration( TransliterationUpdate( parse_atf_lark(updates["transliteration"]), updates["notes"]), user, ), user, fragment.number == MuseumNumber("K", "1"), ), "signs": "", } assert post_result.status == falcon.HTTP_OK assert post_result.json == expected_json get_result = client.simulate_get(f"/fragments/{fragment.number}") assert get_result.json == expected_json assert database["changelog"].find_one({ "resource_id": str(fragment.number), "resource_type": "fragments", "user_profile.name": user.profile["name"], })
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_parse_state_dollar_line_surface_ambiguity(line, expected_line): 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
def test_text(): text = parse_atf_lark("1. kur") transliteration = TransliterationUpdate(text) assert transliteration.text == text
def test_validate_valid_signs(transliteration_factory): TransliterationUpdate(parse_atf_lark("1. šu gid₂"), signs="ŠU BU")
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 get_ebl_transliteration(line): return parse_atf_lark(line)
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_parse_state_dollar_line_invalid(line): with (pytest.raises(TransliterationError)): parse_atf_lark(line)
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