def get_matching_lines(self, query: TransliterationQuery) -> Lines:
line_numbers = query.match(self.signs)
lines = [line.atf for line in self.text.text_lines]
return tuple(
tuple(lines[numbers[0]:numbers[1] + 1])
for numbers, _ in groupby(line_numbers))
def test_query_by_transliteration(signs, is_match, text_repository) -> None:
text_repository.create_chapter(CHAPTER)
result = text_repository.query_by_transliteration(
TransliterationQuery(signs))
expected = [CHAPTER] if is_match else []
assert result == expected
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_search_transliteration_empty(query, expected, fragment_finder,
fragment_repository):
spy2(fragment_repository.query_by_transliteration)
query = TransliterationQuery(query)
test_result = fragment_finder.search_transliteration(query)
verifyZeroInteractions(fragment_repository)
assert test_result == expected
unstub()
def search_transliteration(self, query: TransliterationQuery) -> List[FragmentInfo]:
if query.is_empty():
return []
else:
return [
FragmentInfo.of(fragment, fragment.get_matching_lines(query))
for fragment in self._repository.query_by_transliteration(query)
]
def test_create_query(sign_repository, signs):
for sign in signs:
sign_repository.create(sign)
factory = TransliterationQueryFactory(sign_repository)
atf = "šu\ngid₂"
assert factory.create(atf) == TransliterationQuery([["ŠU"], ["BU"]])
def test_of() -> None:
chapter: Chapter = ChapterFactory.build()
query = TransliterationQuery([["KU"]])
assert ChapterInfo.of(chapter, query) == ChapterInfo(
chapter.id_,
{chapter.manuscripts[0].id: chapter.manuscripts[0].siglum},
[chapter.lines[0]],
{
chapter.manuscripts[0].id: [
cast(TextLine, chapter.manuscripts[0].colophon.lines[0])
]
},
)
def test_searching_texts(client, bibliography, sign_repository, signs,
text_repository):
allow_signs(signs, sign_repository)
chapter = ChapterFactory.build()
allow_references(chapter, bibliography)
text_repository.create_chapter(chapter)
get_result = client.simulate_get("/textsearch?transliteration=ku")
assert get_result.status == falcon.HTTP_OK
assert get_result.json == [
ChapterInfoSchema().dump(
ChapterInfo.of(chapter, TransliterationQuery([["KU"]])))
]
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_regexp(signs, is_match):
query = TransliterationQuery(signs)
match = re.search(
query.regexp,
"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",
)
if is_match:
assert match is not None
else:
assert match is None
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 search_transliteration(
self, query: TransliterationQuery) -> List[ChapterInfo]:
return ([] if query.is_empty() else [
ChapterInfo.of(chapter, query)
for chapter in self._repository.query_by_transliteration(query)
])
def test_is_sequence_empty(query, expected):
query = TransliterationQuery(query)
assert expected == query.is_empty()
def create(self, transliteration: str) -> TransliterationQuery:
signs = [
self._create_signs(line) for line in transliteration.split("\n")
]
return TransliterationQuery(signs)
def _match(
self, query: TransliterationQuery
) -> Sequence[Sequence[Tuple[int, int]]]:
return [query.match(signs) for signs in self.signs]