def test_update_references(
client, fragmentarium, bibliography, parallel_line_injector, user
):
fragment = FragmentFactory.build()
fragmentarium.create(fragment)
reference = ReferenceFactory.build(with_document=True)
bibliography.create(reference.document, ANY_USER)
references = [ReferenceSchema().dump(reference)]
body = json.dumps({"references": references})
url = f"/fragments/{fragment.number}/references"
post_result = client.simulate_post(url, body=body)
expected_json = create_response_dto(
fragment.set_references((reference,)).set_text(
parallel_line_injector.inject_transliteration(fragment.text)
),
user,
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/{fragment.number}")
assert get_result.json == expected_json
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_update_genres(client, fragmentarium, user, database, parameters):
fragment = FragmentFactory.build(genres=parameters["currentGenres"])
fragment_number = fragmentarium.create(fragment)
updates = {"genres": GenreSchema().dump(parameters["newGenres"], many=True)}
post_result = client.simulate_post(
f"/fragments/{fragment_number}/genres", body=json.dumps(updates)
)
expected_json = {
**create_response_dto(
fragment.set_genres(updates["genres"]), user, fragment.number == "K.1"
)
}
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": fragment_number,
"resource_type": "fragments",
"user_profile.name": user.profile["name"],
}
)
def on_post(self, req: Request, resp: Response, number: str) -> None:
try:
user = req.context.user
updated_fragment, has_photo = self._updater.update_genres(
parse_museum_number(number),
GenreSchema().load(req.media["genres"], many=True),
user,
)
resp.media = create_response_dto(updated_fragment, user, has_photo)
except ValueError as error:
raise DataError(error)
def test_update_transliteration_merge_lemmatization(
new_transliteration,
client,
fragmentarium,
signs,
sign_repository,
transliteration_factory,
parallel_line_injector,
user,
):
for sign in signs:
sign_repository.create(sign)
lemmatized_fragment = LemmatizedFragmentFactory.build()
fragmentarium.create(lemmatized_fragment)
lines = lemmatized_fragment.text.atf.split("\n")
lines[1] = new_transliteration
updates = {
"transliteration": "\n".join(lines),
"notes": lemmatized_fragment.notes
}
updated_transliteration = transliteration_factory.create(
updates["transliteration"], updates["notes"])
updated_fragment = lemmatized_fragment.update_transliteration(
updated_transliteration, user)
expected_fragment = attr.evolve(
updated_fragment,
text=attr.evolve(
updated_fragment.text,
lines=parallel_line_injector.inject(updated_fragment.text.lines),
),
)
expected_json = create_response_dto(
expected_fragment,
user,
lemmatized_fragment.number == MuseumNumber("K", "1"),
)
post_result = client.simulate_post(
f"/fragments/{lemmatized_fragment.number}/transliteration",
body=json.dumps(updates),
)
assert post_result.status == falcon.HTTP_OK
assert post_result.json == expected_json
updated_fragment = client.simulate_get(
f"/fragments/{lemmatized_fragment.number}").json
assert updated_fragment == expected_json
def on_post(self, req: Request, resp: Response, number: str) -> None:
try:
user = req.context.user
updated_fragment, has_photo = self._updater.update_transliteration(
parse_museum_number(number),
self._create_transliteration(req.media),
user,
)
resp.media = create_response_dto(updated_fragment, user, has_photo)
except TransliterationError as error:
resp.status = falcon.HTTP_UNPROCESSABLE_ENTITY
resp.media = {
"title": resp.status,
"description": str(error),
"errors": error.errors,
}
except NotLowestJoinError as error:
raise DataError(error) from error
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_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 on_get(self, req: Request, resp: Response, number: str):
user: User = req.context.user
fragment, has_photo = self._finder.find(parse_museum_number(number))
resp.media = create_response_dto(fragment, user, has_photo)
def on_post(self, req, resp, number):
user = req.context.user
updated_fragment, has_photo = self._updater.update_lemmatization(
parse_museum_number(number),
LemmatizationSchema().load(req.media), user)
resp.media = create_response_dto(updated_fragment, user, has_photo)
def on_post(self, req, resp, number) -> None:
user = req.context.user
updated_fragment, has_photo = self._updater.update_references(
parse_museum_number(number),
ReferencesDtoSchema().load(req.media), user)
resp.media = create_response_dto(updated_fragment, user, has_photo)
def test_create_response_dto(user):
lemmatized_fragment = LemmatizedFragmentFactory.build(
joins=Joins(((JoinFactory.build(), ), )))
has_photo = True
assert create_response_dto(
lemmatized_fragment, user, has_photo) == pydash.omit_by(
{
"museumNumber":
attr.asdict(lemmatized_fragment.number),
"accession":
lemmatized_fragment.accession,
"cdliNumber":
lemmatized_fragment.cdli_number,
"bmIdNumber":
lemmatized_fragment.bm_id_number,
"publication":
lemmatized_fragment.publication,
"description":
lemmatized_fragment.description,
"joins":
JoinsSchema().dump(lemmatized_fragment.joins)["fragments"],
"length":
attr.asdict(lemmatized_fragment.length,
filter=lambda _, value: value is not None),
"width":
attr.asdict(lemmatized_fragment.width,
filter=lambda _, value: value is not None),
"thickness":
attr.asdict(lemmatized_fragment.thickness,
filter=lambda _, value: value is not None),
"collection":
lemmatized_fragment.collection,
"script":
lemmatized_fragment.script,
"notes":
lemmatized_fragment.notes,
"museum":
lemmatized_fragment.museum,
"signs":
lemmatized_fragment.signs,
"record": [{
"user": entry.user,
"type": entry.type.value,
"date": entry.date
} for entry in lemmatized_fragment.record.entries],
"folios": [
attr.asdict(folio) for folio in
lemmatized_fragment.folios.filter(user).entries
],
"text":
TextSchema().dump(lemmatized_fragment.text),
"references": [{
"id": reference.id,
"type": reference.type.name,
"pages": reference.pages,
"notes": reference.notes,
"linesCited": list(reference.lines_cited),
} for reference in lemmatized_fragment.references],
"uncuratedReferences": ([
attr.asdict(reference)
for reference in lemmatized_fragment.uncurated_references
] if lemmatized_fragment.uncurated_references is not None else
None),
"atf":
lemmatized_fragment.text.atf,
"hasPhoto":
has_photo,
"genres": [{
"category": genre.category,
"uncertain": genre.uncertain
} for genre in lemmatized_fragment.genres],
"lineToVec": [[
line_to_vec_encoding.value
for line_to_vec_encoding in line_to_vec_encodings
] for line_to_vec_encodings in lemmatized_fragment.line_to_vec
],
},
pydash.is_none,
)
