Add methods for finding chapters for display

ebl/corpus/application/corpus.py

@@ -12,6 +12,7 @@
 from ebl.corpus.application.text_validator import TextValidator
 from ebl.corpus.domain.alignment import Alignment
 from ebl.corpus.domain.chapter import Chapter, ChapterId
+from ebl.corpus.domain.chapter_display import ChapterDisplay
 from ebl.corpus.domain.chapter_info import ChapterInfo
 from ebl.corpus.domain.lines_update import LinesUpdate
 from ebl.corpus.domain.manuscript import Manuscript
@@ -43,6 +44,10 @@ def find(self, id_: TextId) -> Text:
     def find_chapter(self, id_: ChapterId) -> Chapter:
         ...
 
+    @abstractmethod
+    def find_chapter_for_display(self, id_: ChapterId) -> ChapterDisplay:
+        ...
+
     @abstractmethod
     def list(self) -> List[Text]:
         ...
@@ -86,6 +91,9 @@ def find_chapter(self, id_: ChapterId) -> Chapter:
         chapter = self._repository.find_chapter(id_)
         return self._hydrate_references(chapter)
 
+    def find_chapter_for_display(self, id_: ChapterId) -> ChapterDisplay:
+        return self._repository.find_chapter_for_display(id_)
+
     def find_manuscripts(self, id_: ChapterId) -> Sequence[Manuscript]:
         return self._hydrate_manuscripts(
             self._repository.query_manuscripts_by_chapter(id_)

ebl/corpus/application/display_schemas.py

@@ -11,8 +11,10 @@
 
 class LineDisplaySchema(Schema):
     number = fields.Nested(OneOfLineNumberSchema, required=True)
-    reconstruction = fields.List(fields.Nested(OneOfTokenSchema), required=True)
-    translation = fields.List(fields.Nested(OneOfNoteLinePartSchema), required=True)
+    reconstruction = fields.List(fields.Nested(OneOfTokenSchema), load_default=tuple())
+    translation = fields.List(
+        fields.Nested(OneOfNoteLinePartSchema), load_default=tuple()
+    )
 
     @post_load
     def make_line(self, data: dict, **kwargs) -> LineDisplay:

ebl/corpus/domain/chapter_display.py

@@ -1,15 +1,31 @@
-from typing import Sequence
+from typing import Iterable, Sequence
 import attr
 
 from ebl.corpus.domain.chapter import ChapterId, Chapter
 from ebl.corpus.domain.line import Line
 from ebl.corpus.domain.text import Text
-from ebl.transliteration.domain.translation_line import DEFAULT_LANGUAGE
+from ebl.transliteration.domain.translation_line import (
+    DEFAULT_LANGUAGE,
+    TranslationLine,
+)
 from ebl.transliteration.domain.line_number import AbstractLineNumber
 from ebl.transliteration.domain.tokens import Token
 from ebl.transliteration.domain.markup import MarkupPart
 
 
+def get_default_translation(
+    translations: Iterable[TranslationLine],
+) -> Sequence[MarkupPart]:
+    return next(
+        (
+            translation_line.parts
+            for translation_line in translations
+            if translation_line.language == DEFAULT_LANGUAGE
+        ),
+        tuple(),
+    )
+
+
 @attr.s(frozen=True, auto_attribs=True)
 class LineDisplay:
     number: AbstractLineNumber
@@ -21,14 +37,7 @@ def of_line(line: Line) -> "LineDisplay":
         return LineDisplay(
             line.number,
             line.variants[0].reconstruction,
-            next(
-                (
-                    translation_line.parts
-                    for translation_line in line.translation
-                    if translation_line.language == DEFAULT_LANGUAGE
-                ),
-                tuple(),
-            ),
+            get_default_translation(line.translation),
         )
 
 

ebl/corpus/infrastructure/mongo_text_repository.py

@@ -4,16 +4,22 @@
 
 from ebl.bibliography.infrastructure.bibliography import join_reference_documents
 from ebl.corpus.application.corpus import TextRepository
+from ebl.corpus.application.display_schemas import ChapterDisplaySchema
+from ebl.corpus.application.schemas import ChapterSchema, ManuscriptSchema, TextSchema
 from ebl.corpus.domain.chapter import Chapter, ChapterId
+from ebl.corpus.domain.chapter_display import ChapterDisplay
 from ebl.corpus.domain.manuscript import Manuscript
 from ebl.corpus.domain.text import Text, TextId
 from ebl.corpus.infrastructure.collections import CHAPTERS_COLLECTION, TEXTS_COLLECTION
-from ebl.corpus.infrastructure.queries import chapter_id_query, join_chapters
+from ebl.corpus.infrastructure.queries import (
+    aggregate_chapter_display,
+    chapter_id_query,
+    join_chapters,
+)
 from ebl.errors import NotFoundError
+from ebl.fragmentarium.infrastructure.queries import is_in_fragmentarium, join_joins
 from ebl.mongo_collection import MongoCollection
 from ebl.transliteration.domain.transliteration_query import TransliterationQuery
-from ebl.corpus.application.schemas import ChapterSchema, ManuscriptSchema, TextSchema
-from ebl.fragmentarium.infrastructure.queries import is_in_fragmentarium, join_joins
 
 
 def text_not_found(id_: TextId) -> Exception:
@@ -101,6 +107,18 @@ def find_chapter(self, id_: ChapterId) -> Chapter:
         except NotFoundError:
             raise chapter_not_found(id_)
 
+    def find_chapter_for_display(self, id_: ChapterId) -> ChapterDisplay:
+        try:
+            text = self.find(id_.text_id)
+            chapters = self._chapters.aggregate(aggregate_chapter_display(id_))
+            return ChapterDisplaySchema().load(
+                {**next(chapters), "textName": text.name}
+            )
+        except NotFoundError as error:
+            raise text_not_found(id_.text_id) from error
+        except StopIteration as error:
+            raise chapter_not_found(id_) from error
+
     def list(self) -> List[Text]:
         return TextSchema().load(
             self._texts.aggregate(

ebl/corpus/infrastructure/queries.py

@@ -3,6 +3,7 @@
 from ebl.corpus.domain.chapter import ChapterId
 from ebl.corpus.infrastructure.collections import CHAPTERS_COLLECTION
 from ebl.fragmentarium.infrastructure.queries import is_in_fragmentarium
+from ebl.transliteration.domain.translation_line import DEFAULT_LANGUAGE
 
 
 def chapter_id_query(id_: ChapterId) -> dict:
@@ -107,3 +108,69 @@ def join_chapters(include_uncertain_fragmnets: bool) -> List[dict]:
         },
         {"$project": {"_id": 0}},
     ]
+
+
+def aggregate_chapter_display(id_: ChapterId) -> List[dict]:
+    return [
+        {"$match": chapter_id_query(id_)},
+        {
+            "$addFields": {
+                "id": {
+                    "textId": "$textId",
+                    "stage": "$stage",
+                    "name": "$name",
+                },
+                "lines": {
+                    "$map": {
+                        "input": "$lines",
+                        "as": "line",
+                        "in": {
+                            "number": "$$line.number",
+                            "translation": {
+                                "$arrayElemAt": [
+                                    {
+                                        "$map": {
+                                            "input": {
+                                                "$filter": {
+                                                    "input": "$$line.translation",
+                                                    "as": "translation",
+                                                    "cond": {
+                                                        "eq": [
+                                                            "$$translation.language",
+                                                            DEFAULT_LANGUAGE,
+                                                        ]
+                                                    },
+                                                }
+                                            },
+                                            "as": "en_translation",
+                                            "in": "$$en_translation.parts",
+                                        }
+                                    },
+                                    0,
+                                ]
+                            },
+                            "reconstruction": {
+                                "$arrayElemAt": [
+                                    {
+                                        "$map": {
+                                            "input": "$$line.variants",
+                                            "as": "variant",
+                                            "in": "$$variant.reconstruction",
+                                        }
+                                    },
+                                    0,
+                                ]
+                            },
+                        },
+                    }
+                },
+            }
+        },
+        {
+            "$project": {
+                "_id": False,
+                "id": True,
+                "lines": True,
+            }
+        },
+    ]

ebl/tests/corpus/test_corpus.py

@@ -7,7 +7,9 @@
 )
 from ebl.corpus.application.schemas import ChapterSchema
 from ebl.corpus.domain.alignment import Alignment, ManuscriptLineAlignment
+from ebl.corpus.domain.chapter_display import ChapterDisplay
 from ebl.corpus.domain.line import Line, LineVariant, ManuscriptLine
+from ebl.corpus.domain.lines_update import LinesUpdate
 from ebl.corpus.domain.parser import parse_chapter
 from ebl.dictionary.domain.word import WordId
 from ebl.errors import DataError, Defect, NotFoundError
@@ -25,7 +27,7 @@
 from ebl.transliteration.domain.text_line import TextLine
 from ebl.transliteration.domain.tokens import Joiner, LanguageShift, ValueToken
 from ebl.transliteration.domain.word_tokens import Word
-from ebl.corpus.domain.lines_update import LinesUpdate
+
 
 CHAPTERS_COLLECTION = "chapters"
 TEXT = TextFactory.build()
@@ -133,6 +135,15 @@ def test_find_chapter(corpus, text_repository, bibliography, when) -> None:
     assert corpus.find_chapter(CHAPTER.id_) == CHAPTER
 
 
+def test_find_chapter_for_display(corpus, text_repository, when) -> None:
+    chapter_display = ChapterDisplay.of_chapter(TEXT, CHAPTER)
+    when(text_repository).find_chapter_for_display(CHAPTER.id_).thenReturn(
+        chapter_display
+    )
+
+    assert corpus.find_chapter_for_display(CHAPTER.id_) == chapter_display
+
+
 def test_find_manuscripts(corpus, text_repository, bibliography, when) -> None:
     expect_bibliography(bibliography, when)
     when(text_repository).query_manuscripts_by_chapter(CHAPTER.id_).thenReturn(

ebl/tests/corpus/test_mongo_text_repository.py

@@ -2,22 +2,23 @@
 import pytest
 
 from ebl.corpus.application.schemas import ChapterSchema, TextSchema
+from ebl.corpus.domain.chapter_display import ChapterDisplay
+from ebl.corpus.domain.text import UncertainFragment
+from ebl.corpus.domain.text_id import TextId
 from ebl.errors import DuplicateError, NotFoundError
+from ebl.fragmentarium.application.joins_schema import JoinSchema
+from ebl.fragmentarium.domain.fragment import Fragment
+from ebl.fragmentarium.domain.joins import Join, Joins
+from ebl.fragmentarium.domain.museum_number import MuseumNumber
 from ebl.tests.factories.corpus import (
     ChapterFactory,
     LineFactory,
     ManuscriptFactory,
     TextFactory,
 )
-from ebl.transliteration.domain.transliteration_query import TransliterationQuery
-from ebl.transliteration.domain.genre import Genre
-from ebl.corpus.domain.text_id import TextId
-from ebl.fragmentarium.application.joins_schema import JoinSchema
-from ebl.fragmentarium.domain.museum_number import MuseumNumber
-from ebl.fragmentarium.domain.joins import Join, Joins
 from ebl.tests.factories.fragment import FragmentFactory
-from ebl.fragmentarium.domain.fragment import Fragment
-from ebl.corpus.domain.text import UncertainFragment
+from ebl.transliteration.domain.genre import Genre
+from ebl.transliteration.domain.transliteration_query import TransliterationQuery
 
 
 TEXTS_COLLECTION = "texts"
@@ -137,6 +138,21 @@ def test_listing_texts(database, text_repository, bibliography_repository) -> No
     assert text_repository.list() == [TEXT, another_text]
 
 
+def test_finding_chapter(database, text_repository) -> None:
+    when_chapter_in_collection(database)
+
+    assert text_repository.find_chapter(CHAPTER.id_) == CHAPTER
+
+
+def test_finding_chapter_for_display(database, text_repository) -> None:
+    when_text_in_collection(database)
+    when_chapter_in_collection(database)
+
+    assert text_repository.find_chapter_for_display(
+        CHAPTER.id_
+    ) == ChapterDisplay.of_chapter(TEXT, CHAPTER)
+
+
 def test_updating_chapter(database, text_repository) -> None:
     updated_chapter = attr.evolve(
         CHAPTER, lines=tuple(), manuscripts=tuple(), signs=tuple()