fabricatio 0.2.11.dev2__cp312-cp312-win_amd64.whl → 0.2.12__cp312-cp312-win_amd64.whl

fabricatio/models/action.py

@@ -12,12 +12,13 @@ Classes:
 import traceback
 from abc import abstractmethod
 from asyncio import Queue, create_task
-from typing import Any, Dict, Self, Tuple, Type, Union, final
+from typing import Any, Dict, Self, Sequence, Tuple, Type, Union, final
 
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.task import Task
-from fabricatio.models.usages import LLMUsage, ToolBoxUsage
+from fabricatio.models.usages import ToolBoxUsage
+from fabricatio.utils import override_kwargs
 from pydantic import Field, PrivateAttr
 
 OUTPUT_KEY = "task_output"
@@ -25,7 +26,7 @@ OUTPUT_KEY = "task_output"
 INPUT_KEY = "task_input"
 
 
-class Action(WithBriefing, LLMUsage):
+class Action(WithBriefing):
     """Class that represents an action to be executed in a workflow.
 
     Actions are the atomic units of work in a workflow. Each action performs
@@ -55,7 +56,7 @@ class Action(WithBriefing, LLMUsage):
         self.description = self.description or self.__class__.__doc__ or ""
 
     @abstractmethod
-    async def _execute(self, *_:Any, **cxt) -> Any:
+    async def _execute(self, *_: Any, **cxt) -> Any:
         """Implement the core logic of the action.
 
         Args:
@@ -95,11 +96,12 @@ class Action(WithBriefing, LLMUsage):
             return f"## Your personality: \n{self.personality}\n# The action you are going to perform: \n{super().briefing}"
         return f"# The action you are going to perform: \n{super().briefing}"
 
-    def to_task_output(self)->Self:
+    def to_task_output(self, task_output_key: str = OUTPUT_KEY) -> Self:
         """Set the output key to OUTPUT_KEY and return the action instance."""
-        self.output_key=OUTPUT_KEY
+        self.output_key = task_output_key
         return self
 
+
 class WorkFlow(WithBriefing, ToolBoxUsage):
     """Manages sequences of actions to fulfill tasks.
 
@@ -121,9 +123,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
     """Instantiated action objects to be executed in this workflow."""
 
-    steps: Tuple[Union[Type[Action], Action], ...] = Field(
-        frozen=True,
-    )
+    steps: Sequence[Union[Type[Action], Action]] = Field(frozen=True)
     """The sequence of actions to be executed, can be action classes or instances."""
 
     task_input_key: str = Field(default=INPUT_KEY)
@@ -177,7 +177,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         current_action = None
         try:
             # Process each action in sequence
-            for i,step in enumerate(self._instances):
+            for i, step in enumerate(self._instances):
                 current_action = step.name
                 logger.info(f"Executing step [{i}] >> {current_action}")
 
@@ -227,8 +227,13 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
             - Any extra_init_context values
         """
         logger.debug(f"Initializing context for workflow: {self.name}")
-        initial_context = {self.task_input_key: task, **dict(self.extra_init_context)}
-        await self._context.put(initial_context)
+        ctx = override_kwargs(self.extra_init_context, **task.extra_init_context)
+        if self.task_input_key in ctx:
+            raise ValueError(
+                f"Task input key: `{self.task_input_key}`, which is reserved, is already set in the init context"
+            )
+
+        await self._context.put({self.task_input_key: task, **ctx})
 
     def steps_fallback_to_self(self) -> Self:
         """Configure all steps to use this workflow's configuration as fallback.
@@ -245,7 +250,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         Returns:
             Self: The workflow instance for method chaining.
         """
-        self.provide_tools_to(i for i in self._instances if isinstance(i,ToolBoxUsage))
+        self.provide_tools_to(i for i in self._instances if isinstance(i, ToolBoxUsage))
         return self
 
     def update_init_context(self, /, **kwargs) -> Self:

fabricatio/models/extra/aricle_rag.py

@@ -9,7 +9,7 @@ from fabricatio.journal import logger
 from fabricatio.models.extra.rag import MilvusDataBase
 from fabricatio.models.generic import AsPrompt
 from fabricatio.models.kwargs_types import ChunkKwargs
-from fabricatio.rust import BibManager, is_chinese, split_into_chunks
+from fabricatio.rust import BibManager, blake3_hash, split_into_chunks
 from fabricatio.utils import ok
 from more_itertools.recipes import flatten, unique
 from pydantic import Field
@@ -53,7 +53,7 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
 
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {
-            f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}`": self.chunk
+            f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}` from {self.as_auther_seq()}": self.chunk
         }
 
     @property
@@ -139,15 +139,9 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
         return re.sub(r"\[[\d\s,\\~–-]+]", "", string)
 
     @property
-    def auther_firstnames(self) -> List[str]:
-        """Get the first name of the authors."""
-        ret = []
-        for n in self.authors:
-            if is_chinese(n):
-                ret.append(n[0])
-            else:
-                ret.append(n.split()[-1])
-        return ret
+    def auther_lastnames(self) -> List[str]:
+        """Get the last name of the authors."""
+        return [n.split()[-1] for n in self.authors]
 
     def as_auther_seq(self) -> str:
         """Get the auther sequence."""
@@ -155,13 +149,13 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
             case 0:
                 raise ValueError("No authors found")
             case 1:
-                return f"（{self.auther_firstnames[0]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.year}）{self.as_typst_cite()}"
             case 2:
-                return f"（{self.auther_firstnames[0]}{self.and_word}{self.auther_firstnames[1]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}{self.and_word}{self.auther_lastnames[1]}，{self.year}）{self.as_typst_cite()}"
             case 3:
-                return f"（{self.auther_firstnames[0]}，{self.auther_firstnames[1]}{self.and_word}{self.auther_firstnames[2]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.auther_lastnames[1]}{self.and_word}{self.auther_lastnames[2]}，{self.year}）{self.as_typst_cite()}"
             case _:
-                return f"（{self.auther_firstnames[0]}，{self.auther_firstnames[1]}{self.and_word}{self.auther_firstnames[2]}{self.etc_word}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.auther_lastnames[1]}{self.and_word}{self.auther_lastnames[2]}{self.etc_word}，{self.year}）{self.as_typst_cite()}"
 
     def update_cite_number(self, cite_number: int) -> Self:
         """Update the cite number."""
@@ -182,20 +176,32 @@ class CitationManager(AsPrompt):
     abbr_sep: str = "-"
     """Separator for abbreviated citation numbers."""
 
-    def update_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True) -> Self:
+    def update_chunks(
+        self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True
+    ) -> Self:
         """Update article chunks."""
         self.article_chunks.clear()
         self.article_chunks.extend(article_chunks)
+        if dedup:
+            self.article_chunks = list(unique(self.article_chunks, lambda c: blake3_hash(c.chunk.encode())))
         if set_cite_number:
             self.set_cite_number_all()
         return self
 
-    def add_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True)-> Self:
+    def empty(self) -> Self:
+        """Empty the article chunks."""
+        self.article_chunks.clear()
+        return self
+
+    def add_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True) -> Self:
         """Add article chunks."""
         self.article_chunks.extend(article_chunks)
+        if dedup:
+            self.article_chunks = list(unique(self.article_chunks, lambda c: blake3_hash(c.chunk.encode())))
         if set_cite_number:
             self.set_cite_number_all()
         return self
+
     def set_cite_number_all(self) -> Self:
         """Set citation numbers for all article chunks."""
         for i, a in enumerate(self.article_chunks, 1):
@@ -208,7 +214,7 @@ class CitationManager(AsPrompt):
 
     def apply(self, string: str) -> str:
         """Apply citation replacements to the input string."""
-        for origin,m in re.findall(self.pat, string):
+        for origin, m in re.findall(self.pat, string):
             logger.info(f"Matching citation: {m}")
             notations = self.convert_to_numeric_notations(m)
             logger.info(f"Citing Notations: {notations}")
@@ -216,9 +222,26 @@ class CitationManager(AsPrompt):
             logger.info(f"Citation Number Sequence: {citation_number_seq}")
             dedup = self.deduplicate_citation(citation_number_seq)
             logger.info(f"Deduplicated Citation Number Sequence: {dedup}")
-            string=string.replace(origin, self.unpack_cite_seq(dedup))
+            string = string.replace(origin, self.unpack_cite_seq(dedup))
         return string
 
+    def citation_count(self, string: str) -> int:
+        """Get the citation count in the string."""
+        count = 0
+        for _, m in re.findall(self.pat, string):
+            logger.info(f"Matching citation: {m}")
+            notations = self.convert_to_numeric_notations(m)
+            logger.info(f"Citing Notations: {notations}")
+            citation_number_seq = list(flatten(self.decode_expr(n) for n in notations))
+            logger.info(f"Citation Number Sequence: {citation_number_seq}")
+            count += len(dedup := self.deduplicate_citation(citation_number_seq))
+            logger.info(f"Deduplicated Citation Number Sequence: {dedup}")
+        return count
+
+    def citation_coverage(self, string: str) -> float:
+        """Get the citation coverage in the string."""
+        return self.citation_count(string) / len(self.article_chunks)
+
     def decode_expr(self, string: str) -> List[int]:
         """Decode citation expression into a list of integers."""
         if self.abbr_sep in string:

fabricatio/models/extra/article_base.py

@@ -1,6 +1,6 @@
 """A foundation for hierarchical document components with dependency tracking."""
 
-from abc import ABC, abstractmethod
+from abc import ABC
 from enum import StrEnum
 from typing import Generator, List, Optional, Self, Tuple
 
@@ -18,7 +18,8 @@ from fabricatio.models.generic import (
     Titled,
     WordCount,
 )
-from fabricatio.rust import comment
+from fabricatio.rust import split_out_metadata, to_metadata, word_count
+from fabricatio.utils import fallback_kwargs
 from pydantic import Field
 
 
@@ -46,14 +47,49 @@ class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
     aims: List[str]
     """List of writing aims of the research component in academic style."""
 
+    @property
+    def typst_metadata_comment(self) -> str:
+        """Generates a comment for the metadata of the article component."""
+        return to_metadata(self.model_dump(include={"description", "aims", "expected_word_count"}, by_alias=True))
+
+
+class FromTypstCode(ArticleMetaData):
+    """Base class for article components that can be created from a Typst code snippet."""
+
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
+        """Converts a Typst code snippet into an article component."""
+        data, body = split_out_metadata(body)
+
+        return cls(
+            heading=title,
+            **fallback_kwargs(
+                data or {},
+                elaboration="",
+                expected_word_count=word_count(body),
+                aims=[],
+            ),
+            **kwargs,
+        )
+
+
+class ToTypstCode(ArticleMetaData):
+    """Base class for article components that can be converted to a Typst code snippet."""
+
+    def to_typst_code(self) -> str:
+        """Converts the component into a Typst code snippet for rendering."""
+        return f"{self.title}\n{self.typst_metadata_comment}\n"
+
 
 class ArticleOutlineBase(
-    ArticleMetaData,
     ResolveUpdateConflict,
     ProposedUpdateAble,
     PersistentAble,
     ModelHash,
     Introspect,
+    FromTypstCode,
+    ToTypstCode,
+    ABC,
 ):
     """Base class for article outlines."""
 
@@ -79,23 +115,13 @@ class ArticleOutlineBase(
         """Updates the current instance with the attributes of another instance."""
         return self.update_metadata(other)
 
-    @abstractmethod
-    def to_typst_code(self) -> str:
-        """Converts the component into a Typst code snippet for rendering."""
-
 
 class SubSectionBase(ArticleOutlineBase):
     """Base class for article sections and subsections."""
 
     def to_typst_code(self) -> str:
         """Converts the component into a Typst code snippet for rendering."""
-        return (
-            f"=== {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        )
+        return f"=== {super().to_typst_code()}"
 
     def introspect(self) -> str:
         """Introspects the article subsection outline."""
@@ -120,13 +146,7 @@ class SectionBase[T: SubSectionBase](ArticleOutlineBase):
         Returns:
             str: The formatted Typst code snippet.
         """
-        return (
-            f"== {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
+        return f"== {super().to_typst_code()}" + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
 
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
@@ -169,13 +189,7 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
 
     def to_typst_code(self) -> str:
         """Converts the chapter into a Typst formatted code snippet for rendering."""
-        return (
-            f"= {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(sec.to_typst_code() for sec in self.sections)
+        return f"= {super().to_typst_code()}" + "\n\n".join(sec.to_typst_code() for sec in self.sections)
 
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
@@ -207,12 +221,13 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
         return ""
 
 
-class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Described, Titled, Language, ABC):
+class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, ToTypstCode, ABC):
     """Base class for article outlines."""
 
-    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,
+    description: str = Field(
+        alias="elaboration",
+    )
+    """The abstract of this article, which 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,
@@ -297,6 +312,10 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Descri
         for _, _, subsec in self.iter_subsections():
             yield subsec.title
 
+    def to_typst_code(self) -> str:
+        """Generates the Typst code representation of the article."""
+        return f"// #{super().to_typst_code()}\n\n" + "\n\n".join(a.to_typst_code() for a in self.chapters)
+
     def finalized_dump(self) -> str:
         """Generates standardized hierarchical markup for academic publishing systems.
 
@@ -317,8 +336,31 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Descri
             === Implementation Details
             == Evaluation Protocol
         """
-        return comment(
-            f"Title:{self.title}\nDesc:\n{self.description}\n" + f"Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(a.to_typst_code() for a in self.chapters)
+        return self.to_typst_code()
+
+    def avg_chap_wordcount[S: "ArticleBase"](self: S) -> S:
+        """Set all chap have same word count sum up to be `self.expected_word_count`."""
+        avg = int(self.expected_word_count / len(self.chapters))
+        for c in self.chapters:
+            c.expected_word_count = avg
+        return self
+
+    def avg_sec_wordcount[S: "ArticleBase"](self: S) -> S:
+        """Set all sec have same word count sum up to be `self.expected_word_count`."""
+        for c in self.chapters:
+            avg = int(c.expected_word_count / len(c.sections))
+            for s in c.sections:
+                s.expected_word_count = avg
+        return self
+
+    def avg_subsec_wordcount[S: "ArticleBase"](self: S) -> S:
+        """Set all subsec have same word count sum up to be `self.expected_word_count`."""
+        for _, s in self.iter_sections():
+            avg = int(s.expected_word_count / len(s.subsections))
+            for ss in s.subsections:
+                ss.expected_word_count = avg
+        return self
+
+    def avg_wordcount_recursive[S: "ArticleBase"](self: S) -> S:
+        """Set all chap, sec, subsec have same word count sum up to be `self.expected_word_count`."""
+        return self.avg_chap_wordcount().avg_sec_wordcount().avg_subsec_wordcount()

fabricatio/models/extra/article_main.py

@@ -12,13 +12,22 @@ from fabricatio.models.extra.article_base import (
     SubSectionBase,
 )
 from fabricatio.models.extra.article_outline import (
+    ArticleChapterOutline,
     ArticleOutline,
+    ArticleSectionOutline,
+    ArticleSubsectionOutline,
 )
 from fabricatio.models.generic import Described, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
-from fabricatio.rust import convert_all_block_tex, convert_all_inline_tex, word_count
+from fabricatio.rust import (
+    convert_all_block_tex,
+    convert_all_inline_tex,
+    fix_misplaced_labels,
+    split_out_metadata,
+    word_count,
+)
 from pydantic import Field, NonNegativeInt
 
-PARAGRAPH_SEP = "// - - -"
+PARAGRAPH_SEP = "\n\n// - - -\n\n"
 
 
 class Paragraph(SketchedAble, WordCount, Described):
@@ -89,17 +98,17 @@ class ArticleSubsection(SubSectionBase):
         Returns:
             str: Typst code snippet for rendering.
         """
-        return f"=== {self.title}\n" + f"\n{PARAGRAPH_SEP}\n".join(p.content for p in self.paragraphs)
+        return super().to_typst_code() + PARAGRAPH_SEP.join(p.content for p in self.paragraphs)
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str) -> Self:
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> 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),
-            aims=[],
+        _, para_body = split_out_metadata(body)
+
+        return super().from_typst_code(
+            title,
+            body,
+            paragraphs=[Paragraph.from_content(p) for p in para_body.split(PARAGRAPH_SEP)],
         )
 
 
@@ -107,16 +116,14 @@ class ArticleSection(SectionBase[ArticleSubsection]):
     """Atomic argumentative unit with high-level specificity."""
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str) -> Self:
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Creates an Article object from the given Typst code."""
-        return cls(
+        return super().from_typst_code(
+            title,
+            body,
             subsections=[
                 ArticleSubsection.from_typst_code(*pack) for pack in extract_sections(body, level=3, section_char="=")
             ],
-            heading=title,
-            elaboration="",
-            expected_word_count=word_count(body),
-            aims=[],
         )
 
 
@@ -124,21 +131,18 @@ class ArticleChapter(ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str) -> Self:
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Creates an Article object from the given Typst code."""
-        return cls(
+        return super().from_typst_code(
+            title,
+            body,
             sections=[
                 ArticleSection.from_typst_code(*pack) for pack in extract_sections(body, level=2, section_char="=")
             ],
-            heading=title,
-            elaboration="",
-            expected_word_count=word_count(body),
-            aims=[],
         )
 
 
 class Article(
-    SketchedAble,
     WithRef[ArticleOutline],
     PersistentAble,
     ArticleBase[ArticleChapter],
@@ -157,30 +161,70 @@ class Article(
             "Original Article": self.display(),
         }
 
-    def convert_tex(self) -> Self:
+    def convert_tex(self, paragraphs: bool = True, descriptions: bool = True) -> Self:
         """Convert tex to typst code."""
-        for _, _, subsec in self.iter_subsections():
-            for p in subsec.paragraphs:
-                p.content = convert_all_inline_tex(p.content)
-                p.content = convert_all_block_tex(p.content)
-        return self
-
-    def fix_wrapper(self) -> Self:
-        """Fix wrapper."""
-        for _, _, subsec in self.iter_subsections():
-            for p in subsec.paragraphs:
-                p.content = (
-                    p.content.replace(r" \( ", "$")
-                    .replace(r" \) ", "$")
-                    .replace("\\[\n", "$$\n")
-                    .replace("\n\\]", "\n$$")
-                )
+        if descriptions:
+            for a in self.iter_dfs():
+                a.description = fix_misplaced_labels(a.description)
+                a.description = convert_all_inline_tex(a.description)
+                a.description = convert_all_block_tex(a.description)
+
+        if paragraphs:
+            for _, _, subsec in self.iter_subsections():
+                for p in subsec.paragraphs:
+                    p.content = fix_misplaced_labels(p.content)
+                    p.content = convert_all_inline_tex(p.content)
+                    p.content = convert_all_block_tex(p.content)
         return self
 
     @override
     def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
         return super().iter_subsections()  # pyright: ignore [reportReturnType]
 
+    def extrac_outline(self) -> ArticleOutline:
+        """Extract outline from article."""
+        # Create an empty list to hold chapter outlines
+        chapters = []
+
+        # Iterate through each chapter in the article
+        for chapter in self.chapters:
+            # Create an empty list to hold section outlines
+            sections = []
+
+            # Iterate through each section in the chapter
+            for section in chapter.sections:
+                # Create an empty list to hold subsection outlines
+                subsections = []
+
+                # Iterate through each subsection in the section
+                for subsection in section.subsections:
+                    # Create a subsection outline and add it to the list
+                    subsections.append(
+                        ArticleSubsectionOutline(**subsection.model_dump(exclude={"paragraphs"}, by_alias=True))
+                    )
+
+                # Create a section outline and add it to the list
+                sections.append(
+                    ArticleSectionOutline(
+                        **section.model_dump(exclude={"subsections"}, by_alias=True),
+                        subsections=subsections,
+                    )
+                )
+
+            # Create a chapter outline and add it to the list
+            chapters.append(
+                ArticleChapterOutline(
+                    **chapter.model_dump(exclude={"sections"}, by_alias=True),
+                    sections=sections,
+                )
+            )
+
+        # Create and return the article outline
+        return ArticleOutline(
+            **self.model_dump(exclude={"chapters"}, by_alias=True),
+            chapters=chapters,
+        )
+
     @classmethod
     def from_outline(cls, outline: ArticleOutline) -> "Article":
         """Generates an article from the given outline.
@@ -218,15 +262,14 @@ class Article(
         return article
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str) -> Self:
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Generates an article from the given Typst code."""
-        return cls(
+        return super().from_typst_code(
+            title,
+            body,
             chapters=[
                 ArticleChapter.from_typst_code(*pack) for pack in extract_sections(body, level=1, section_char="=")
             ],
-            heading=title,
-            expected_word_count=word_count(body),
-            abstract="",
         )
 
     @classmethod
@@ -248,3 +291,4 @@ class Article(
 
         for a in self.iter_dfs():
             a.title = await text(f"Edit `{a.title}`.", default=a.title).ask_async() or a.title
+        return self