Add endpoint for chapter display (#170)

* Update dependencies

* Extract method to get chapter title

* Remove spurious commas

* Upgrade black and format

It works with pypy again: psf/black#727

* Add model for cahpter display

* Move ChapterIdSchema to id_schemas

* Add schema for ChapterDisplay

* Add methods for finding chapters for display

* 'Refactored by Sourcery' (#176)

Co-authored-by: Sourcery AI <>

* Add route for chapter display

* Remove Theia settings

* Add title to ChapterDisplay

* Add title to ChapterDisplay schema

* Add intertext to line display

* Get intertext from database

* Add is_single_stage to ChapterDisplay

Co-authored-by: sourcery-ai[bot] <58596630+sourcery-ai[bot]@users.noreply.github.com>

Pipfile

@@ -39,7 +39,7 @@ pyhamcrest = "*"
 flake8-bugbear = "*"
 httpretty = "*"
 pyre-check = "==0.0.60"
-black = "==19.3b0"
+black = "*"
 pymongo-inmemory = "*"
 pillow = "*"
 pytest-xdist = "*"

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

@@ -0,0 +1,46 @@
+from marshmallow import Schema, fields, post_load
+
+from ebl.corpus.application.id_schemas import ChapterIdSchema
+from ebl.corpus.domain.chapter_display import ChapterDisplay, LineDisplay
+from ebl.transliteration.application.line_number_schemas import OneOfLineNumberSchema
+from ebl.transliteration.application.note_line_part_schemas import (
+    OneOfNoteLinePartSchema,
+)
+from ebl.transliteration.application.token_schemas import OneOfTokenSchema
+
+
+class LineDisplaySchema(Schema):
+    number = fields.Nested(OneOfLineNumberSchema, required=True)
+    intertext = fields.List(
+        fields.Nested(OneOfNoteLinePartSchema), load_default=tuple()
+    )
+    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:
+        return LineDisplay(
+            data["number"],
+            tuple(data["intertext"]),
+            tuple(data["reconstruction"]),
+            tuple(data["translation"]),
+        )
+
+
+class ChapterDisplaySchema(Schema):
+    id_ = fields.Nested(ChapterIdSchema, required=True, data_key="id")
+    text_name = fields.String(required=True, data_key="textName")
+    is_single_stage = fields.Boolean(required=True, data_key="isSingleStage")
+    title = fields.List(fields.Nested(OneOfNoteLinePartSchema), dump_only=True)
+    lines = fields.Nested(LineDisplaySchema, many=True, required=True)
+
+    @post_load
+    def make_chapter(self, data: dict, **kwargs) -> ChapterDisplay:
+        return ChapterDisplay(
+            data["id_"],
+            data["text_name"],
+            data["is_single_stage"],
+            tuple(data["lines"]),
+        )

ebl/corpus/application/id_schemas.py

@@ -1,5 +1,7 @@
-from marshmallow import fields, post_load, Schema, validate
+from marshmallow import Schema, fields, post_load, validate
 
+from ebl.corpus.domain.chapter import ChapterId
+from ebl.corpus.domain.stage import Stage
 from ebl.corpus.domain.text_id import TextId
 from ebl.schemas import ValueEnum
 from ebl.transliteration.domain.genre import Genre
@@ -13,3 +15,13 @@ class TextIdSchema(Schema):
     @post_load
     def make_id(self, data, **kwargs) -> TextId:
         return TextId(data["genre"], data["category"], data["index"])
+
+
+class ChapterIdSchema(Schema):
+    text_id = fields.Nested(TextIdSchema, required=True, data_key="textId")
+    stage = ValueEnum(Stage, required=True)
+    name = fields.String(required=True, validate=validate.Length(min=1))
+
+    @post_load
+    def make_id(self, data, **kwargs) -> ChapterId:
+        return ChapterId(data["text_id"], data["stage"], data["name"])

ebl/corpus/domain/chapter.py

@@ -12,6 +12,11 @@
 from ebl.errors import NotFoundError
 from ebl.fragmentarium.domain.museum_number import MuseumNumber
 from ebl.merger import Merger
+from ebl.transliteration.domain.markup import MarkupPart, to_title
+from ebl.transliteration.domain.translation_line import (
+    DEFAULT_LANGUAGE,
+    TranslationLine,
+)
 from ebl.transliteration.domain.text_line import TextLine
 from ebl.transliteration.domain.transliteration_query import TransliterationQuery
 import ebl.corpus.domain.chapter_validators as validators
@@ -59,6 +64,17 @@ def __str__(self) -> str:
         return f"{self.text_id} {self.stage.abbreviation} {self.name}"
 
 
+def make_title(translation: Sequence[TranslationLine]) -> Sequence[MarkupPart]:
+    return next(
+        (
+            to_title(line.parts)
+            for line in translation
+            if line.language == DEFAULT_LANGUAGE
+        ),
+        tuple(),
+    )
+
+
 @attr.s(auto_attribs=True, frozen=True)
 class Chapter:
     text_id: TextId

ebl/corpus/domain/chapter_display.py

@@ -0,0 +1,68 @@
+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,
+    TranslationLine,
+)
+from ebl.transliteration.domain.line_number import AbstractLineNumber
+from ebl.transliteration.domain.tokens import Token
+from ebl.transliteration.domain.markup import MarkupPart, to_title
+
+
+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
+    intertext: Sequence[MarkupPart]
+    reconstruction: Sequence[Token]
+    translation: Sequence[MarkupPart]
+
+    @property
+    def title(self) -> Sequence[MarkupPart]:
+        return to_title(self.translation)
+
+    @staticmethod
+    def of_line(line: Line) -> "LineDisplay":
+        return LineDisplay(
+            line.number,
+            line.variants[0].intertext,
+            line.variants[0].reconstruction,
+            get_default_translation(line.translation),
+        )
+
+
+@attr.s(frozen=True, auto_attribs=True)
+class ChapterDisplay:
+    id_: ChapterId
+    text_name: str
+    is_single_stage: bool
+    lines: Sequence[LineDisplay]
+
+    @property
+    def title(self) -> Sequence[MarkupPart]:
+        return self.lines[0].title if self.lines else tuple()
+
+    @staticmethod
+    def of_chapter(text: Text, chapter: Chapter) -> "ChapterDisplay":
+        return ChapterDisplay(
+            chapter.id_,
+            text.name,
+            not text.has_multiple_stages,
+            tuple(map(LineDisplay.of_line, chapter.lines)),
+        )