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
