def test_find_transliterated(database, fragment_repository):
transliterated_fragment_1 = TransliteratedFragmentFactory.build(
number=MuseumNumber.of("X.1")
)
transliterated_fragment_2 = TransliteratedFragmentFactory.build(
number=MuseumNumber.of("X.2")
)
database[COLLECTION].insert_many(
[
{
**SCHEMA.dump(transliterated_fragment_2),
"_id": str(transliterated_fragment_2.number),
},
SCHEMA.dump(FragmentFactory.build()),
{
**SCHEMA.dump(transliterated_fragment_1),
"_id": str(transliterated_fragment_1.number),
},
]
)
assert fragment_repository.query_transliterated_numbers() == [
transliterated_fragment_1.number,
transliterated_fragment_2.number,
]
def test_fragment_matcher_route_error(client, fragmentarium, user):
faulty_fragment_id = "X.-1"
fragment_1 = TransliteratedFragmentFactory.build(number=MuseumNumber.of("X.0"))
fragment_2 = TransliteratedFragmentFactory.build(
number=MuseumNumber.of("X.1"),
line_to_vec=(LineToVecEncoding.from_list([1, 1, 2]),),
)
fragmentarium.create(fragment_1)
fragmentarium.create(fragment_2)
get_result = client.simulate_get(f"/fragments/{faulty_fragment_id}/match")
assert get_result.status == falcon.HTTP_UNPROCESSABLE_ENTITY
def test_update_lemmatization(
fragment_updater, user, fragment_repository, parallel_line_injector, changelog, when
):
transliterated_fragment = TransliteratedFragmentFactory.build()
number = transliterated_fragment.number
tokens = [list(line) for line in transliterated_fragment.text.lemmatization.tokens]
tokens[1][3] = LemmatizationToken(tokens[1][3].value, ("aklu I",))
lemmatization = Lemmatization(tokens)
lemmatized_fragment = transliterated_fragment.update_lemmatization(lemmatization)
(
when(fragment_repository)
.query_by_museum_number(number)
.thenReturn(transliterated_fragment)
)
injected_fragment = lemmatized_fragment.set_text(
parallel_line_injector.inject_transliteration(lemmatized_fragment.text)
)
when(changelog).create(
"fragments",
user.profile,
{"_id": str(number), **SCHEMA.dump(transliterated_fragment)},
{"_id": str(number), **SCHEMA.dump(lemmatized_fragment)},
).thenReturn()
when(fragment_repository).update_lemmatization(lemmatized_fragment).thenReturn()
result = fragment_updater.update_lemmatization(number, lemmatization, user)
assert result == (injected_fragment, False)
def test_signs_get(
client,
annotations_repository,
photo_repository,
when,
fragment_repository,
text_with_labels,
):
fragment = TransliteratedFragmentFactory.build(
number=MuseumNumber.of("K.2"), text=text_with_labels)
fragment_repository.create(fragment)
annotation_data = AnnotationDataFactory.build(sign_name="signName",
path=[2, 0, 0])
annotation = AnnotationFactory.build(data=annotation_data)
annotations_repository.create_or_update(
AnnotationsFactory.build(fragment_number="K.2",
annotations=[annotation]))
result = client.simulate_get("/signs/signName/images")
assert len(result.json) > 0
result_json = result.json[0]
assert result_json["fragmentNumber"] == str(fragment.number)
assert isinstance(result_json["image"], str)
assert result_json["script"] == fragment.script
assert result_json["label"] == "i Stone wig Stone wig 2"
assert result.status == falcon.HTTP_OK
def test_update_lemmatization(client, fragmentarium, user, database):
transliterated_fragment = TransliteratedFragmentFactory.build()
fragmentarium.create(transliterated_fragment)
tokens = [
list(line)
for line in transliterated_fragment.text.lemmatization.tokens
]
tokens[1][3] = LemmatizationToken(tokens[1][3].value, ("aklu I", ))
lemmatization = Lemmatization(tokens)
body = LemmatizationSchema().dumps(lemmatization)
url = f"/fragments/{transliterated_fragment.number}/lemmatization"
post_result = client.simulate_post(url, body=body)
expected_json = create_response_dto(
transliterated_fragment.update_lemmatization(lemmatization),
user,
transliterated_fragment.number == MuseumNumber("K", "1"),
)
assert post_result.status == falcon.HTTP_OK
assert post_result.json == expected_json
get_result = client.simulate_get(
f"/fragments/{transliterated_fragment.number}")
assert get_result.json == expected_json
assert database["changelog"].find_one({
"resource_id":
str(transliterated_fragment.number),
"resource_type":
"fragments",
"user_profile.name":
user.profile["name"],
})
def test_cropped_images_from_sign(
annotations_repository,
photo_repository,
fragment_repository,
when,
text_with_labels,
):
image_extractor = AnnotationImageExtractor(fragment_repository,
annotations_repository,
photo_repository)
single_annotation = AnnotationFactory.build(
data=AnnotationDataFactory.build(path=[2, 0, 0]))
annotation = AnnotationsFactory.build(annotations=[single_annotation])
sign = "test-sign"
fragment = TransliteratedFragmentFactory.build(text=text_with_labels)
(when(annotations_repository).find_by_sign(sign).thenReturn([annotation]))
(when(fragment_repository).query_by_museum_number(
annotation.fragment_number).thenReturn(fragment))
(when(photo_repository).query_by_file_name(
f"{annotation.fragment_number}.jpg").thenReturn(
create_test_photo("K.2")))
result = image_extractor.cropped_images_from_sign(sign)
assert len(result) > 0
first_cropped_annotation = result[0]
assert isinstance(first_cropped_annotation, CroppedAnnotation)
assert first_cropped_annotation.script == fragment.script
assert first_cropped_annotation.label == "i Stone wig Stone wig 2"
def test_search_signs(signs, is_match, fragment_repository):
transliterated_fragment = TransliteratedFragmentFactory.build()
fragment_repository.create(transliterated_fragment)
fragment_repository.create(FragmentFactory.build())
result = fragment_repository.query_by_transliteration(TransliterationQuery(signs))
expected = [transliterated_fragment] if is_match else []
assert result == expected
def test_needs_revision(client, fragmentarium):
transliterated_fragment = TransliteratedFragmentFactory.build()
fragmentarium.create(transliterated_fragment)
result = client.simulate_get("/fragments", params={"needsRevision": True})
assert result.status == falcon.HTTP_OK
assert result.json == [expected_fragment_info_dto(transliterated_fragment)]
assert result.headers["Cache-Control"] == "private, max-age=600"
def test_random(client, fragmentarium):
transliterated_fragment = TransliteratedFragmentFactory.build()
fragmentarium.create(transliterated_fragment)
result = client.simulate_get("/fragments", params={"random": True})
assert result.status == falcon.HTTP_OK
assert result.json == [expected_fragment_info_dto(transliterated_fragment)]
assert "Cache-Control" not in result.headers
def test_find_random(fragment_repository):
fragment = FragmentFactory.build()
transliterated_fragment = TransliteratedFragmentFactory.build()
for a_fragment in fragment, transliterated_fragment:
fragment_repository.create(a_fragment)
assert fragment_repository.query_random_by_transliterated() == [
transliterated_fragment
]
def test_inject_transliteration(parallel_line_injector, parallel_repository,
when):
transliteration = TransliteratedFragmentFactory.build().text
when(parallel_repository).chapter_exists(...).thenReturn(True)
when(parallel_repository).fragment_exists(...).thenReturn(True)
assert parallel_line_injector.inject_transliteration(
transliteration) == attr.evolve(transliteration,
lines=parallel_line_injector.inject(
transliteration.lines))
def test_fragment_matcher_route(client, fragmentarium, user):
fragment_id = "X.15"
fragment_1 = TransliteratedFragmentFactory.build(number=MuseumNumber.of("X.15"))
fragment_2 = TransliteratedFragmentFactory.build(
number=MuseumNumber.of("X.326"),
line_to_vec=(LineToVecEncoding.from_list([1, 1, 2]),),
)
expected_score = {
"score": [{"museumNumber": "X.326", "script": fragment_2.script, "score": 3}],
"scoreWeighted": [
{"museumNumber": "X.326", "script": fragment_2.script, "score": 5}
],
}
fragmentarium.create(fragment_1)
fragmentarium.create(fragment_2)
get_result = client.simulate_get(f"/fragments/{fragment_id}/match")
assert get_result.status == falcon.HTTP_OK
assert get_result.json == expected_score
def test_update_lemmatization_atf_change(client, fragmentarium):
transliterated_fragment = TransliteratedFragmentFactory.build()
fragmentarium.create(transliterated_fragment)
dto = LemmatizationSchema().dump(
transliterated_fragment.text.lemmatization)
dto["lemmatization"][0][0]["value"] = "ana"
url = f"/fragments/{transliterated_fragment.number}/lemmatization"
post_result = client.simulate_post(url, body=json.dumps(dto))
assert post_result.status == falcon.HTTP_UNPROCESSABLE_ENTITY
def test_update_lemmatization(fragment_repository):
transliterated_fragment = TransliteratedFragmentFactory.build()
fragment_repository.create(transliterated_fragment)
tokens = [list(line) for line in transliterated_fragment.text.lemmatization.tokens]
tokens[1][3] = LemmatizationToken(tokens[1][3].value, ("aklu I",))
lemmatization = Lemmatization(tokens)
updated_fragment = transliterated_fragment.update_lemmatization(lemmatization)
fragment_repository.update_lemmatization(updated_fragment)
result = fragment_repository.query_by_museum_number(transliterated_fragment.number)
assert result == updated_fragment
def test_find_transliterated_line_to_vec(database, fragment_repository):
transliterated_fragment = TransliteratedFragmentFactory.build()
database[COLLECTION].insert_many(
[SCHEMA.dump(transliterated_fragment), SCHEMA.dump(FragmentFactory.build())]
)
assert fragment_repository.query_transliterated_line_to_vec() == [
LineToVecEntry(
transliterated_fragment.number,
transliterated_fragment.script,
transliterated_fragment.line_to_vec,
)
]
def test_update_lemmatization():
transliterated_fragment = TransliteratedFragmentFactory.build()
tokens = [
list(line)
for line in transliterated_fragment.text.lemmatization.tokens
]
tokens[1][3] = LemmatizationToken(tokens[1][3].value, ("nu I", ))
lemmatization = Lemmatization(tokens)
expected = attr.evolve(
transliterated_fragment,
text=transliterated_fragment.text.update_lemmatization(lemmatization),
)
assert transliterated_fragment.update_lemmatization(
lemmatization) == expected
def test_search_signs(client, fragmentarium, sign_repository, signs):
transliterated_fragment = TransliteratedFragmentFactory.build()
fragmentarium.create(transliterated_fragment)
for sign in signs:
sign_repository.create(sign)
result = client.simulate_get("/fragments",
params={"transliteration": "ma-tu₂"})
assert result.status == falcon.HTTP_OK
assert result.json == [
expected_fragment_info_dto(transliterated_fragment,
(("6'. [...] x# mu ta-ma;-tu₂", ), ))
]
assert "Cache-Control" not in result.headers
def test_search_transliteration(fragment_finder, fragment_repository, when):
transliterated_fragment = TransliteratedFragmentFactory.build()
sign_matrix = [["MA", "UD"]]
query = TransliterationQuery(sign_matrix)
matching_fragments = [transliterated_fragment]
(when(fragment_repository).query_by_transliteration(query).thenReturn(
matching_fragments))
expected_lines = (("6'. [...] x# mu ta-ma;-tu₂", ), )
expected = [
FragmentInfo.of(fragment, expected_lines)
for fragment in matching_fragments
]
assert fragment_finder.search_transliteration(query) == expected
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_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_get(client, fragmentarium, parallel_line_injector, user):
transliterated_fragment = TransliteratedFragmentFactory.build()
fragmentarium.create(transliterated_fragment)
result = client.simulate_get(
f"/fragments/{transliterated_fragment.number}")
expected_fragment = attr.evolve(
transliterated_fragment,
text=attr.evolve(
transliterated_fragment.text,
lines=parallel_line_injector.inject(
transliterated_fragment.text.lines),
),
)
expected = create_response_dto(
expected_fragment,
user,
transliterated_fragment.number == MuseumNumber("K", "1"),
)
assert result.json == expected
assert result.status == falcon.HTTP_OK
def test_update_update_references(fragment_repository):
transliterated_fragment = TransliteratedFragmentFactory.build()
with pytest.raises(NotFoundError):
fragment_repository.update_references(transliterated_fragment)
def test_create_line_to_vec():
fragment = TransliteratedFragmentFactory()
line_to_vec = create_line_to_vec(fragment.text.lines)
assert fragment.line_to_vec == line_to_vec
def test_update_update_lemmatization_not_found(fragment_repository):
transliterated_fragment = TransliteratedFragmentFactory.build()
with pytest.raises(NotFoundError):
fragment_repository.update_lemmatization(transliterated_fragment)
def test_signs():
transliterated_fragment = TransliteratedFragmentFactory.build()
assert transliterated_fragment.signs == TransliteratedFragmentFactory.signs
from ebl.transliteration.domain.normalized_akkadian import AkkadianWord
from ebl.transliteration.domain.parallel_line import Labels, ParallelFragment
from ebl.transliteration.domain.sign_tokens import Logogram, Reading
from ebl.transliteration.domain.text import Text
from ebl.transliteration.domain.text_line import TextLine
from ebl.transliteration.domain.tokens import Joiner, ValueToken
from ebl.transliteration.domain.transliteration_query import TransliterationQuery
from ebl.transliteration.domain.word_tokens import Word
from ebl.fragmentarium.domain.joins import Join, Joins
COLLECTION = "fragments"
JOINS_COLLECTION = "joins"
ANOTHER_LEMMATIZED_FRAGMENT = attr.evolve(
TransliteratedFragmentFactory.build(),
text=Text(
(
TextLine(
LineNumber(1),
(
Word.of(
[Logogram.of_name("GI", 6)], unique_lemma=(WordId("ginâ I"),)
),
Word.of([Reading.of_name("ana")], unique_lemma=(WordId("ana II"),)),
Word.of([Reading.of_name("ana")], unique_lemma=(WordId("ana II"),)),
Word.of(
[
Reading.of_name("u", 4),
Joiner.hyphen(),
Reading.of_name("šu"),
def test_inject_other_lines(parallel_line_injector):
lines = tuple(line
for line in TransliteratedFragmentFactory.build().text.lines
if not isinstance(line, (ParallelFragment, ParallelText)))
assert parallel_line_injector.inject(lines) == lines
