fabricatio 0.2.9.dev2__cp312-cp312-win_amd64.whl → 0.2.9.dev4__cp312-cp312-win_amd64.whl

fabricatio/models/extra/article_base.py

@@ -7,15 +7,20 @@ from typing import Generator, List, Optional, Self, Tuple, overload
 
 from fabricatio.models.generic import (
     AsPrompt,
+    Described,
     FinalizedDumpAble,
     Introspect,
+    Language,
     ModelHash,
     PersistentAble,
     ProposedUpdateAble,
     ResolveUpdateConflict,
     SequencePatch,
     SketchedAble,
+    Titled,
+    WordCount,
 )
+from pydantic import Field
 
 
 class ReferringType(StrEnum):
@@ -36,44 +41,44 @@ class ArticleRef(ProposedUpdateAble):
         - Referring to a chapter titled `Introduction`:
             Using Python
             ```python
-            ArticleRef(referred_chapter_title="Introduction")
+            ArticleRef(chap="Introduction")
             ```
             Using JSON
             ```json
-            {referred_chapter_title="Introduction"}
+            {chap="Introduction"}
             ```
         - Referring to a section titled `Background` under the `Introduction` chapter:
             Using Python
             ```python
-            ArticleRef(referred_chapter_title="Introduction", referred_section_title="Background")
+            ArticleRef(chap="Introduction", sec="Background")
             ```
             Using JSON
             ```json
-            {referred_chapter_title="Introduction", referred_section_title="Background"}
+            {chap="Introduction", sec="Background"}
             ```
         - Referring to a subsection titled `Related Work` under the `Background` section of the `Introduction` chapter:
             Using Python
             ```python
-            ArticleRef(referred_chapter_title="Introduction", referred_section_title="Background", referred_subsection_title="Related Work")
+            ArticleRef(chap="Introduction", sec="Background", subsec="Related Work")
             ```
             Using JSON
             ```json
-            {referred_chapter_title="Introduction", referred_section_title="Background", referred_subsection_title="Related Work"}
+            {chap="Introduction", sec="Background", subsec="Related Work"}
             ```
     """
 
-    referred_chapter_title: str
+    chap: str
     """`title` Field of the referenced chapter"""
-    referred_section_title: Optional[str] = None
+    sec: Optional[str] = None
     """`title` Field of the referenced section."""
-    referred_subsection_title: Optional[str] = None
+    subsec: Optional[str] = None
     """`title` Field of the referenced subsection."""
 
     def update_from_inner(self, other: Self) -> Self:
         """Updates the current instance with the attributes of another instance."""
-        self.referred_chapter_title = other.referred_chapter_title
-        self.referred_section_title = other.referred_section_title
-        self.referred_subsection_title = other.referred_subsection_title
+        self.chap = other.chap
+        self.sec = other.sec
+        self.subsec = other.subsec
         return self
 
     def deref(self, article: "ArticleBase") -> Optional["ArticleOutlineBase"]:
@@ -85,42 +90,41 @@ class ArticleRef(ProposedUpdateAble):
         Returns:
             ArticleMainBase | ArticleOutline | None: The dereferenced section or subsection, or None if not found.
         """
-        chap = next((chap for chap in article.chapters if chap.title == self.referred_chapter_title), None)
-        if self.referred_section_title is None or chap is None:
+        chap = next((chap for chap in article.chapters if chap.title == self.chap), None)
+        if self.sec is None or chap is None:
             return chap
-        sec = next((sec for sec in chap.sections if sec.title == self.referred_section_title), None)
-        if self.referred_subsection_title is None or sec is None:
+        sec = next((sec for sec in chap.sections if sec.title == self.sec), None)
+        if self.subsec is None or sec is None:
             return sec
-        return next((subsec for subsec in sec.subsections if subsec.title == self.referred_subsection_title), None)
+        return next((subsec for subsec in sec.subsections if subsec.title == self.subsec), None)
 
     @property
     def referring_type(self) -> ReferringType:
         """Determine the type of reference based on the presence of specific attributes."""
-        if self.referred_subsection_title is not None:
+        if self.subsec is not None:
             return ReferringType.SUBSECTION
-        if self.referred_section_title is not None:
+        if self.sec is not None:
             return ReferringType.SECTION
         return ReferringType.CHAPTER
 
 
-class ArticleMetaData(SketchedAble):
+class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
     """Metadata for an article component."""
 
-    description: str
-    """Description of the research component in academic style."""
+    description: str = Field(
+        alias="elaboration",
+        description=Described.model_fields["description"].description,
+    )
 
-    support_to: List[ArticleRef]
-    """List of references to other component of this articles that this component supports."""
-    depend_on: List[ArticleRef]
-    """List of references to other component of this articles that this component depends on."""
+    title: str = Field(alias="heading", description=Titled.model_fields["title"].description)
 
-    writing_aim: List[str]
+    aims: List[str]
     """List of writing aims of the research component in academic style."""
-    title: str
-    """Do not add any prefix or suffix to the title. should not contain special characters."""
 
-    expected_word_count: int
-    """Expected word count of this research component."""
+    support_to: List[ArticleRef]
+    """List of references to other future components in this article that this component supports to."""
+    depend_on: List[ArticleRef]
+    """List of references to other previous components in this article that this component depends on."""
 
 
 class ArticleRefSequencePatch(SequencePatch[ArticleRef]):
@@ -148,8 +152,8 @@ class ArticleOutlineBase(
         self.support_to.extend(other.support_to)
         self.depend_on.clear()
         self.depend_on.extend(other.depend_on)
-        self.writing_aim.clear()
-        self.writing_aim.extend(other.writing_aim)
+        self.aims.clear()
+        self.aims.extend(other.aims)
         self.description = other.description
         return self
 
@@ -273,25 +277,19 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
         return ""
 
 
-class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, ABC):
+class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Described, Titled, Language, ABC):
     """Base class for article outlines."""
 
-    language: str
-    """Written language of the article. SHALL be aligned to the language of the article proposal provided."""
+    title: str = Field(alias="heading", description=Titled.model_fields["title"].description)
+    description: str = Field(alias="abstract")
+    """The abstract serves as a concise summary of an academic article, encapsulating its core purpose, methodologies, key results,
+    and conclusions while enabling readers to rapidly assess the relevance and significance of the study.
+    Functioning as the article's distilled essence, it succinctly articulates the research problem, objectives,
+    and scope, providing a roadmap for the full text while also facilitating database indexing, literature reviews,
+    and citation tracking through standardized metadata. Additionally, it acts as an accessibility gateway,
+    allowing scholars to gauge the study's contribution to existing knowledge, its methodological rigor,
+    and its broader implications without engaging with the entire manuscript, thereby optimizing scholarly communication efficiency."""
 
-    title: str
-    """Title of the academic paper."""
-
-    prospect: str
-    """Consolidated research statement with four pillars:
-    1. Problem Identification: Current limitations
-    2. Methodological Response: Technical approach
-    3. Empirical Validation: Evaluation strategy
-    4. Scholarly Impact: Field contributions
-    """
-
-    abstract: str
-    """The abstract is a concise summary of the academic paper's main findings."""
     chapters: List[T]
     """Chapters of the article. Contains at least one chapter. You can also add more as needed."""
 
@@ -378,12 +376,31 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, ABC):
                 return component, summary
         return None
 
+    def gather_introspected(self) -> Optional[str]:
+        """Gathers all introspected components in the article structure."""
+        return "\n".join([i for component in self.chapters if (i := component.introspect())])
+
     @overload
     def find_illegal_ref(self, gather_identical: bool) -> Optional[Tuple[ArticleRef | List[ArticleRef], str]]: ...
 
     @overload
     def find_illegal_ref(self) -> Optional[Tuple[ArticleRef, str]]: ...
 
+    def iter_chap_title(self) -> Generator[str, None, None]:
+        """Iterates through all chapter titles in the article."""
+        for chap in self.chapters:
+            yield chap.title
+
+    def iter_section_title(self) -> Generator[str, None, None]:
+        """Iterates through all section titles in the article."""
+        for _, sec in self.iter_sections():
+            yield sec.title
+
+    def iter_subsection_title(self) -> Generator[str, None, None]:
+        """Iterates through all subsection titles in the article."""
+        for _, _, subsec in self.iter_subsections():
+            yield subsec.title
+
     def find_illegal_ref(self, gather_identical: bool = False) -> Optional[Tuple[ArticleRef | List[ArticleRef], str]]:
         """Finds the first illegal component in the outline.
 
@@ -391,21 +408,64 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, ABC):
             Tuple[ArticleOutlineBase, str]: A tuple containing the illegal component and an error message.
         """
         summary = ""
+        chap_titles_set = set(self.iter_chap_title())
+        sec_titles_set = set(self.iter_section_title())
+        subsec_titles_set = set(self.iter_subsection_title())
+
         for component in self.iter_dfs_rev():
             for ref in chain(component.depend_on, component.support_to):
                 if not ref.deref(self):
                     summary += f"Invalid internal reference in `{component.__class__.__name__}` titled `{component.title}`, because the referred {ref.referring_type} is not exists within the article, see the original obj dump: {ref.model_dump()}\n"
-                if summary and not gather_identical:
-                    return ref, summary
-                if summary and gather_identical:
-                    return [
-                        identical_ref
-                        for identical_ref in chain(self.iter_depend_on(), self.iter_support_on())
-                        if identical_ref == ref
-                    ], summary
+
+                    if ref.chap not in (chap_titles_set):
+                        summary += f"Chapter titled `{ref.chap}` is not any of {chap_titles_set}\n"
+                    if ref.sec and ref.sec not in (sec_titles_set):
+                        summary += f"Section Titled `{ref.sec}` is not any of {sec_titles_set}\n"
+                    if ref.subsec and ref.subsec not in (subsec_titles_set):
+                        summary += f"Subsection Titled `{ref.subsec}` is not any of {subsec_titles_set}"
+
+                if summary:
+                    return (
+                        (
+                            [
+                                identical_ref
+                                for identical_ref in chain(self.iter_depend_on(), self.iter_support_on())
+                                if identical_ref == ref
+                            ],
+                            summary,
+                        )
+                        if gather_identical
+                        else (ref, summary)
+                    )
 
         return None
 
+    def gather_illegal_ref(self) -> Tuple[List[ArticleRef], str]:
+        """Gathers all illegal references in the article."""
+        summary = []
+        chap_titles_set = set(self.iter_chap_title())
+        sec_titles_set = set(self.iter_section_title())
+        subsec_titles_set = set(self.iter_subsection_title())
+        res_seq = []
+
+        for component in self.iter_dfs():
+            for ref in (
+                r for r in chain(component.depend_on, component.support_to) if not r.deref(self) and r not in res_seq
+            ):
+                res_seq.append(ref)
+                if ref.chap not in chap_titles_set:
+                    summary.append(
+                        f"Chapter titled `{ref.chap}` is not exist, since it is not any of {chap_titles_set}."
+                    )
+                if ref.sec and (ref.sec not in sec_titles_set):
+                    summary.append(f"Section Titled `{ref.sec}` is not exist, since it is not any of {sec_titles_set}")
+                if ref.subsec and (ref.subsec not in subsec_titles_set):
+                    summary.append(
+                        f"Subsection Titled `{ref.subsec}` is not exist, since it is not any of {subsec_titles_set}"
+                    )
+
+        return res_seq, "\n".join(summary)
+
     def finalized_dump(self) -> str:
         """Generates standardized hierarchical markup for academic publishing systems.
 

fabricatio/models/extra/article_main.py

@@ -3,6 +3,7 @@
 from itertools import chain
 from typing import Dict, Generator, List, Self, Tuple, override
 
+from fabricatio.fs.readers import extract_sections
 from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
     ArticleBase,
@@ -14,22 +15,33 @@ from fabricatio.models.extra.article_base import (
 from fabricatio.models.extra.article_outline import (
     ArticleOutline,
 )
-from fabricatio.models.generic import PersistentAble, SequencePatch, SketchedAble, WithRef
+from fabricatio.models.generic import Described, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
+from fabricatio.rust import detect_language, word_count
 from fabricatio.utils import ok
+from pydantic import Field
 
+PARAGRAPH_SEP = "// - - -"
 
-class Paragraph(SketchedAble):
+
+class Paragraph(SketchedAble, WordCount, Described):
     """Structured academic paragraph blueprint for controlled content generation."""
 
-    description: str
-    """Functional summary of the paragraph's role in document structure."""
+    description: str = Field(
+        alias="elaboration",
+        description=Described.model_fields["description"].description,
+    )
 
-    writing_aim: List[str]
+    aims: List[str]
     """Specific communicative objectives for this paragraph's content."""
 
     content: str
     """The actual content of the paragraph, represented as a string."""
 
+    @classmethod
+    def from_content(cls, content: str) -> Self:
+        """Create a Paragraph object from the given content."""
+        return cls(elaboration="", aims=[], expected_word_count=word_count(content), content=content)
+
 
 class ArticleParagraphSequencePatch(SequencePatch[Paragraph]):
     """Patch for `Paragraph` list of `ArticleSubsection`."""
@@ -41,11 +53,25 @@ class ArticleSubsection(SubSectionBase):
     paragraphs: List[Paragraph]
     """List of Paragraph objects containing the content of the subsection."""
 
+    _max_word_count_deviation: float = 0.3
+    """Maximum allowed deviation from the expected word count, as a percentage."""
+
+    @property
+    def word_count(self) -> int:
+        """Calculates the total word count of all paragraphs in the subsection."""
+        return sum(word_count(p.content) for p in self.paragraphs)
+
     def introspect(self) -> str:
-        """Introspects the subsection and returns a message if it has no paragraphs."""
+        """Introspects the subsection and returns a summary of its state."""
+        summary = ""
         if len(self.paragraphs) == 0:
-            return f"`{self.__class__.__name__}` titled `{self.title}` have no paragraphs, to achieve the goal of `{self.writing_aim}`."
-        return ""
+            summary += f"`{self.__class__.__name__}` titled `{self.title}` have no paragraphs, You should add some!\n"
+        if abs((wc := self.word_count) - self.expected_word_count) / self.expected_word_count > self._max_word_count_deviation:
+            summary += (
+                f"`{self.__class__.__name__}` titled `{self.title}` have {wc} words, expected {self.word_count} words!"
+            )
+
+        return summary
 
     def update_from_inner(self, other: Self) -> Self:
         """Updates the current instance with the attributes of another instance."""
@@ -61,16 +87,64 @@ class ArticleSubsection(SubSectionBase):
         Returns:
             str: Typst code snippet for rendering.
         """
-        return f"=== {self.title}\n" + "\n\n".join(p.content for p in self.paragraphs)
+        return f"=== {self.title}\n" + f"\n{PARAGRAPH_SEP}\n".join(p.content for p in self.paragraphs)
+
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, language: str) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return cls(
+            heading=title,
+            elaboration="",
+            paragraphs=[Paragraph.from_content(p) for p in body.split(PARAGRAPH_SEP)],
+            expected_word_count=word_count(body),
+            language=language,
+            aims=[],
+            support_to=[],
+            depend_on=[],
+        )
 
 
 class ArticleSection(SectionBase[ArticleSubsection]):
     """Atomic argumentative unit with high-level specificity."""
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, language: str) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return cls(
+            subsections=[
+                ArticleSubsection.from_typst_code(*pack, language=language)
+                for pack in extract_sections(body, level=3, section_char="=")
+            ],
+            heading=title,
+            elaboration="",
+            expected_word_count=word_count(body),
+            language=language,
+            aims=[],
+            support_to=[],
+            depend_on=[],
+        )
+
 
 class ArticleChapter(ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, language: str) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return cls(
+            sections=[
+                ArticleSection.from_typst_code(*pack, language=language)
+                for pack in extract_sections(body, level=2, section_char="=")
+            ],
+            heading=title,
+            elaboration="",
+            expected_word_count=word_count(body),
+            language=language,
+            aims=[],
+            support_to=[],
+            depend_on=[],
+        )
+
 
 class Article(
     SketchedAble,
@@ -94,7 +168,7 @@ class Article(
 
     @override
     def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
-        return super().iter_subsections()
+        return super().iter_subsections()  # pyright: ignore [reportReturnType]
 
     @classmethod
     def from_outline(cls, outline: ArticleOutline) -> "Article":
@@ -107,31 +181,45 @@ class Article(
             Article: The generated article.
         """
         # Set the title from the outline
-        article = Article(**outline.model_dump(exclude={"chapters"}), chapters=[])
+        article = Article(**outline.model_dump(exclude={"chapters"}, by_alias=True), chapters=[])
 
         for chapter in outline.chapters:
             # Create a new chapter
             article_chapter = ArticleChapter(
                 sections=[],
-                **chapter.model_dump(exclude={"sections"}),
+                **chapter.model_dump(exclude={"sections"}, by_alias=True),
             )
             for section in chapter.sections:
                 # Create a new section
                 article_section = ArticleSection(
                     subsections=[],
-                    **section.model_dump(exclude={"subsections"}),
+                    **section.model_dump(exclude={"subsections"}, by_alias=True),
                 )
                 for subsection in section.subsections:
                     # Create a new subsection
                     article_subsection = ArticleSubsection(
                         paragraphs=[],
-                        **subsection.model_dump(),
+                        **subsection.model_dump(by_alias=True),
                     )
                     article_section.subsections.append(article_subsection)
                 article_chapter.sections.append(article_section)
             article.chapters.append(article_chapter)
         return article
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str) -> Self:
+        """Generates an article from the given Typst code."""
+        return cls(
+            language=(lang := detect_language(body)),
+            chapters=[
+                ArticleChapter.from_typst_code(*pack, language=lang)
+                for pack in extract_sections(body, level=1, section_char="=")
+            ],
+            heading=title,
+            expected_word_count=word_count(body),
+            abstract="",
+        )
+
     def gather_dependencies(self, article: ArticleOutlineBase) -> List[ArticleOutlineBase]:
         """Gathers dependencies for all sections and subsections in the article.
 

fabricatio/models/extra/article_proposal.py

@@ -2,21 +2,25 @@
 
 from typing import Dict, List
 
-from fabricatio.models.generic import AsPrompt, SketchedAble, PersistentAble, WithRef
-
-
-class ArticleProposal(SketchedAble, WithRef[str], AsPrompt, PersistentAble):
+from fabricatio.models.generic import (
+    AsPrompt,
+    Described,
+    Language,
+    PersistentAble,
+    SketchedAble,
+    Titled,
+    WithRef,
+    WordCount,
+)
+from pydantic import Field
+
+
+class ArticleProposal(SketchedAble, WithRef[str], AsPrompt, PersistentAble, WordCount, Described, Titled, Language):
     """Structured proposal for academic paper development with core research elements.
 
     Guides LLM in generating comprehensive research proposals with clearly defined components.
     """
 
-    language: str
-    """The language in which the article is written. This should align with the language specified in the article briefing."""
-
-    title: str
-    """The title of the academic paper, formatted in Title Case."""
-
     focused_problem: List[str]
     """A list of specific research problems or questions that the paper aims to address."""
 
@@ -38,12 +42,9 @@ class ArticleProposal(SketchedAble, WithRef[str], AsPrompt, PersistentAble):
     keywords: List[str]
     """A list of keywords that represent the main topics and focus areas of the research."""
 
-    abstract: str
+    description: str = Field(alias="abstract")
     """A concise summary of the research proposal, outlining the main points and objectives."""
 
-    expected_word_count: int
-    """The estimated word count of the final academic paper."""
-
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {
             "ArticleBriefing": self.referenced,

fabricatio/models/extra/patches.py

@@ -3,17 +3,17 @@
 from typing import Optional, Type
 
 from fabricatio.models.extra.rule import RuleSet
-from fabricatio.models.generic import Patch, WithBriefing
+from fabricatio.models.generic import Language, Patch, WithBriefing
 from pydantic import BaseModel
 
 
-class BriefingPatch[T: WithBriefing](Patch[T], WithBriefing):
-    """Patch class for updating the description and name of a `WithBriefing` object, all fields within this instance will be directly copied onto the target model's field."""
+class BriefingMetadata[T: WithBriefing](Patch[T], WithBriefing):
+    """A patch class for updating the description and name of a `WithBriefing` object, all fields within this instance will be directly copied onto the target model's field."""
 
 
-class RuleSetBriefingPatch(BriefingPatch[RuleSet]):
-    """Patch class for updating the description and name of a `RuleSet` object, all fields within this instance will be directly copied onto the target model's field."""
-    language: str
+class RuleSetMetadata(BriefingMetadata[RuleSet], Language):
+    """A patch class for updating the description and name of a `RuleSet` object, all fields within this instance will be directly copied onto the target model's field."""
+
     @staticmethod
     def ref_cls() -> Optional[Type[BaseModel]]:
         """Get the reference class of the model."""

fabricatio/models/extra/problem.py

@@ -1,7 +1,7 @@
 """A class representing a problem-solution pair identified during a review process."""
 
 from itertools import chain
-from typing import List, Literal, Optional, Self
+from typing import Any, List, Literal, Optional, Self, Tuple, Unpack
 
 from fabricatio.journal import logger
 from fabricatio.models.generic import SketchedAble, WithBriefing
@@ -51,7 +51,12 @@ class ProblemSolutions(SketchedAble):
     problem: Problem
     """The problem identified in the review."""
     solutions: List[Solution]
-    """A collection of potential solutions."""
+    """A collection of potential solutions, spread the thought, add more solution as possible.Do not leave this as blank"""
+
+    def model_post_init(self, context: Any, /) -> None:
+        """Initialize the problem-solution pair with a problem and a list of solutions."""
+        if len(self.solutions) == 0:
+            logger.warning(f"No solution found for problem {self.problem.name}, please add more solutions manually.")
 
     def update_from_inner(self, other: Self) -> Self:
         """Update the current instance with another instance's attributes."""
@@ -69,6 +74,10 @@ class ProblemSolutions(SketchedAble):
         self.solutions = solutions
         return self
 
+    def has_solutions(self) -> bool:
+        """Check if the problem-solution pair has any solutions."""
+        return len(self.solutions) > 0
+
     async def edit_problem(self) -> Self:
         """Interactively edit the problem description."""
         self.problem = Problem.model_validate_strings(
@@ -87,11 +96,11 @@ class ProblemSolutions(SketchedAble):
         """Check if the improvement is decided."""
         return len(self.solutions) == 1
 
-    def final_solution(self) -> Optional[Solution]:
+    def final_solution(self, always_use_first: bool = False) -> Optional[Solution]:
         """Get the final solution."""
-        if not self.decided():
+        if not always_use_first and not self.decided():
             logger.error(
-                f"There is more than one solution for problem {self.problem.name}, please decide which solution is eventually adopted."
+                f"There is {len(self.solutions)} solutions for problem {self.problem.name}, please decide which solution is eventually adopted."
             )
             return None
         return self.solutions[0]
@@ -106,6 +115,10 @@ class Improvement(SketchedAble):
     problem_solutions: List[ProblemSolutions]
     """Collection of problems identified during review along with their potential solutions."""
 
+    def all_problems_have_solutions(self) -> bool:
+        """Check if all problems have solutions."""
+        return all(ps.has_solutions() for ps in self.problem_solutions)
+
     async def supervisor_check(self, check_solutions: bool = True) -> Self:
         """Perform an interactive review session to filter problems and solutions.
 
@@ -145,9 +158,9 @@ class Improvement(SketchedAble):
         return all(ps.decided() for ps in self.problem_solutions)
 
     @classmethod
-    def gather(cls, *improvements: Self) -> Self:
+    def gather(cls, *improvements: Unpack[Tuple["Improvement", ...]]) -> Self:
         """Gather multiple improvements into a single instance."""
         return cls(
-            focused_on="\n".join(imp.focused_on for imp in improvements),
+            focused_on=";".join(imp.focused_on for imp in improvements),
             problem_solutions=list(chain(*(imp.problem_solutions for imp in improvements))),
         )