fabricatio 0.2.7.dev4__cp312-cp312-win_amd64.whl → 0.2.7.dev5__cp312-cp312-win_amd64.whl

fabricatio/actions/article.py

@@ -61,7 +61,7 @@ class GenerateArticleProposal(Action):
             logger.error("Task not approved, since all inputs are None.")
             return None
 
-        return (
+        return ok(
             await self.propose(
                 ArticleProposal,
                 briefing := (
@@ -70,14 +70,15 @@ class GenerateArticleProposal(Action):
                         ok(
                             article_briefing_path
                             or await self.awhich_pathstr(
-                                f"{task_input.briefing}\nExtract the path of file which contains the article briefing."
+                                f"{ok(task_input).briefing}\nExtract the path of file which contains the article briefing."
                             ),
                             "Could not find the path of file to read.",
                         )
                     )
                 ),
                 **self.prepend_sys_msg(),
-            )
+            ),
+            "Could not generate the proposal."
         ).update_ref(briefing)
 
 
@@ -92,27 +93,33 @@ class GenerateOutline(Action):
         article_proposal: ArticleProposal,
         **_,
     ) -> Optional[ArticleOutline]:
-        out = await self.propose(
-            ArticleOutline,
-            article_proposal.as_prompt(),
-            **self.prepend_sys_msg(),
+        out = ok(
+            await self.propose(
+                ArticleOutline,
+                article_proposal.as_prompt(),
+                **self.prepend_sys_msg(),
+            ),
+            "Could not generate the outline.",
         )
 
-        manual = await self.draft_rating_manual(
+        manual = ok(await self.draft_rating_manual(
             topic=(
                 topic
                 := "Fix the internal referring error, make sure there is no more `ArticleRef` pointing to a non-existing article component."
             ),
-        )
-        while err := out.resolve_ref_error():
+        ),"Could not generate the rating manual.")
+
+        while pack := out.find_illegal():
+            component, err = ok(pack)
             logger.warning(f"Found error in the outline: \n{err}")
-            out = await self.correct_obj(
-                out,
-                reference=f"# Referring Error\n{err}",
+            corrected = ok(await self.correct_obj(
+                component,
+                reference=f"# Original Article Outline\n{out.display()}\n# Error Need to be fixed\n{err}",
                 topic=topic,
                 rating_manual=manual,
                 supervisor_check=False,
-            )
+            ),"Could not correct the component.")
+            component.update_from(corrected)
         return out.update_ref(article_proposal)
 
 
@@ -156,15 +163,15 @@ class GenerateArticle(Action):
     ) -> Optional[Article]:
         article: Article = Article.from_outline(article_outline).update_ref(article_outline)
 
-        writing_manual = await self.draft_rating_manual(
+        writing_manual = ok(await self.draft_rating_manual(
             topic=(
                 topic_1
                 := "improve the content of the subsection to fit the outline. SHALL never add or remove any section or subsection, you can only add or delete paragraphs within the subsection."
             ),
-        )
-        err_resolve_manual = await self.draft_rating_manual(
+        ))
+        err_resolve_manual = ok(await self.draft_rating_manual(
             topic=(topic_2 := "this article component has violated the constrain, please correct it.")
-        )
+        ))
         for c, deps in article.iter_dfs_with_deps(chapter=False):
             logger.info(f"Updating the article component: \n{c.display()}")
 
@@ -180,7 +187,7 @@ class GenerateArticle(Action):
                 ),
                 "Could not correct the article component.",
             )
-            while err := c.resolve_update_error(out):
+            while err := c.resolve_update_conflict(out):
                 logger.warning(f"Found error in the article component: \n{err}")
                 out = ok(
                     await self.correct_obj(

fabricatio/models/extra/article_base.py

@@ -1,11 +1,19 @@
 """A foundation for hierarchical document components with dependency tracking."""
-
-from abc import abstractmethod
+from abc import ABC
 from enum import StrEnum
-from typing import TYPE_CHECKING, List, Optional, Self, Union, final, overload
-
-from fabricatio.models.generic import Base, CensoredAble, Display, PersistentAble
-from pydantic import Field
+from typing import TYPE_CHECKING, Generator, List, Optional, Self, Union, overload
+
+from fabricatio.models.generic import (
+    Base,
+    CensoredAble,
+    Display,
+    Introspect,
+    ModelHash,
+    PersistentAble,
+    ProposedAble,
+    ResolveUpdateConflict,
+    UpdateFrom,
+)
 
 if TYPE_CHECKING:
     from fabricatio.models.extra.article_main import Article
@@ -15,9 +23,9 @@ if TYPE_CHECKING:
 class ReferringType(StrEnum):
     """Enumeration of different types of references that can be made in an article."""
 
-    CHAPTER: str = "chapter"
-    SECTION: str = "section"
-    SUBSECTION: str = "subsection"
+    CHAPTER = "chapter"
+    SECTION = "section"
+    SUBSECTION = "subsection"
 
 
 class ArticleRef(CensoredAble):
@@ -103,90 +111,181 @@ class ArticleRef(CensoredAble):
         return ReferringType.CHAPTER
 
 
-class SubSectionBase(Base):
+class SubSectionBase(
+    UpdateFrom,
+    Introspect,
+):
     """Base class for article sections and subsections."""
 
+    title: str
+    """Title of the subsection, do not add any prefix or suffix to the title. should not contain special characters."""
 
-class SectionBase[T: SubSectionBase](Base):
-    """Base class for article sections and subsections."""
-
-    subsections: List[T] = Field(min_length=1)
-    """List of subsections, each containing a specific research component. Must contains at least 1 subsection, But do remember you should always add more subsection as required."""
+    def to_typst_code(self) -> str:
+        """Converts the component into a Typst code snippet for rendering."""
+        return f"=== {self.title}\n"
 
+    def update_from_inner(self, other: Self) -> Self:
+        return self
 
-class ChapterBase[T: SectionBase](Base):
-    """Base class for article chapters."""
+    def introspect(self) -> str:
+        """Introspects the article subsection outline."""
+        return ""
 
-    sections: List[T] = Field(min_length=1)
-    """List of sections, each containing a specific research component. Must contains at least 1 section, But do remember you should always add more section as required."""
+    def resolve_update_conflict(self, other: Self) -> str:
+        """Resolve update errors in the article outline."""
+        if self.title != other.title:
+            return f"Title mismatched, expected `{self.title}`, got `{other.title}`"
+        return ""
 
 
-class ArticleBase[T: ChapterBase](Base):
-    """Base class for article outlines."""
+class SectionBase[T: SubSectionBase](
+    UpdateFrom,
+    Introspect,
+):
+    """Base class for article sections and subsections."""
 
-    chapters: List[T] = Field(min_length=5)
-    """List of chapters, each containing a specific research component. Must contains at least 5 chapters, But do remember you should always add more chapter as required."""
+    subsections: List[T]
+    """Subsections of the section. Contains at least one subsection. You can also add more as needed."""
+    title: str
+    """Title of the section, do not add any prefix or suffix to the title. should not contain special characters."""
 
+    def to_typst_code(self) -> str:
+        """Converts the section into a Typst formatted code snippet.
 
-class ArticleOutlineBase(Base):
-    """Base class for article outlines."""
+        Returns:
+            str: The formatted Typst code snippet.
+        """
+        return f"== {self.title}\n" + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
 
-    title: str
-    """Title of the research component in academic style."""
-    description: str
-    """Description of the research component in academic style."""
+    def resolve_update_conflict(self, other: Self) -> str:
+        """Resolve update errors in the article outline."""
+        out = ""
+        if self.title != other.title:
+            out += f"Title mismatched, expected `{self.title}`, got `{other.title}`"
+        if len(self.subsections) != len(other.subsections):
+            out += f"Section count mismatched, expected `{len(self.subsections)}`, got `{len(other.subsections)}`"
+        return out or "\n".join(
+            [
+                conf
+                for s, o in zip(self.subsections, other.subsections, strict=True)
+                if (conf := s.resolve_update_conflict(o))
+            ]
+        )
+
+    def update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        if len(self.subsections) == 0:
+            self.subsections = other.subsections
+            return self
 
-    support_to: List[ArticleRef]
-    """Required: List of all essential ArticleRef objects identifying components this section provides evidence for.
-    Format: Each reference must point to a specific chapter, section, or subsection.
-    Note: References form a directed acyclic graph in the document structure."""
-    depend_on: List[ArticleRef]
-    """Required: List of all essential ArticleRef objects identifying components this section builds upon.
-    Format: Each reference must point to a previously defined chapter, section, or subsection.
-    Note: Circular dependencies are not permitted."""
+        for self_subsec, other_subsec in zip(self.subsections, other.subsections, strict=True):
+            self_subsec.update_from(other_subsec)
+        return self
 
-    writing_aim: List[str]
-    """Required: List of specific rhetorical objectives (3-5 items).
-    Format: Each item must be an actionable phrase starting with a verb.
-    Example: ['Establish metric validity', 'Compare with baseline approaches',
-             'Justify threshold selection']"""
+    def introspect(self) -> str:
+        """Introspects the article section outline."""
+        if len(self.subsections) == 0:
+            return f"Section `{self.title}` contains no subsections, expected at least one, but got 0, you can add one or more as needed."
+        return ""
 
 
-class ArticleMainBase(CensoredAble, Display, ArticleOutlineBase, PersistentAble):
-    """Foundation for hierarchical document components with dependency tracking."""
+class ChapterBase[T: SectionBase](
+    UpdateFrom,
+    Introspect,
+):
+    """Base class for article chapters."""
 
-    @abstractmethod
+    sections: List[T]
+    """Sections of the chapter. Contains at least one section. You can also add more as needed."""
+    title: str
+    """Title of the chapter, do not add any prefix or suffix to the title. should not contain special characters."""
     def to_typst_code(self) -> str:
-        """Converts the component into a Typst code snippet for rendering."""
+        """Converts the chapter into a Typst formatted code snippet for rendering."""
+        return f"= {self.title}\n" + "\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."""
+        out = ""
 
-    def _update_pre_check(self, other: Self) -> Self:
-        if not isinstance(other, self.__class__):
-            raise TypeError(f"Cannot update from a non-{self.__class__} instance.")
         if self.title != other.title:
-            raise ValueError("Cannot update from a different title.")
+            out += f"Title mismatched, expected `{self.title}`, got `{other.title}`"
+        if len(self.sections) == len(other.sections):
+            out += f"Chapter count mismatched, expected `{len(self.sections)}`, got `{len(other.sections)}`"
+
+        return out or "\n".join(
+            [conf for s, o in zip(self.sections, other.sections, strict=True) if (conf := s.resolve_update_conflict(o))]
+        )
+
+    def update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        if len(self.sections) == 0:
+            self.sections = other.sections
+            return self
+
+        for self_sec, other_sec in zip(self.sections, other.sections, strict=True):
+            self_sec.update_from(other_sec)
         return self
 
-    @abstractmethod
-    def resolve_update_error(self, other: Self) -> str:
-        """Resolve update errors in the article outline.
+    def introspect(self) -> str:
+        """Introspects the article chapter outline."""
+        if len(self.sections) == 0:
+            return f"Chapter `{self.title}` contains no sections, expected at least one, but got 0, you can add one or more as needed."
+        return ""
+
+
+class ArticleBase[T: ChapterBase](Base):
+    """Base class for article outlines."""
+
+    chapters: List[T]
+    """Chapters of the article. Contains at least one chapter. You can also add more as needed."""
+    title: str
+    """Title of the article outline, do not add any prefix or suffix to the title. should not contain special characters."""
+
+    def iter_dfs(
+        self,
+    ) -> Generator[ChapterBase | SectionBase | SubSectionBase, None, None]:
+        """Performs a depth-first search (DFS) through the article structure.
 
         Returns:
-            str: Error message indicating update errors in the article outline.
+            Generator[ArticleMainBase]: Each component in the article structure.
         """
+        for chap in self.chapters:
+            for sec in chap.sections:
+                yield from sec.subsections
+                yield sec
+            yield chap
+
+
+class ArticleOutlineBase(
+    CensoredAble,
+    UpdateFrom,
+    ResolveUpdateConflict,
+    ProposedAble,
+    PersistentAble,
+    Display,
+    ModelHash,
+    ABC,
+):
+    """Base class for article outlines."""
 
-    @abstractmethod
-    def _update_from_inner(self, other: Self) -> Self:
-        """Updates the current instance with the attributes of another instance."""
+    description: str
+    """Description of the research component in academic style."""
 
-    @final
-    def update_from(self, other: Self) -> Self:
-        """Updates the current instance with the attributes of another instance."""
-        return self._update_pre_check(other)._update_from_inner(other)
+    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."""
 
-    def __eq__(self, other: "ArticleMainBase") -> bool:
-        """Compares two ArticleBase objects based on their model_dump_json representation."""
-        return self.model_dump_json() == other.model_dump_json()
+    writing_aim: List[str]
+    """List of writing aims of the research component in academic style."""
 
-    def __hash__(self) -> int:
-        """Calculates a hash value for the ArticleBase object based on its model_dump_json representation."""
-        return hash(self.model_dump_json())
+    def update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        self.support_to.clear()
+        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.description = other.description
+        return self

fabricatio/models/extra/article_main.py

@@ -1,12 +1,12 @@
 """ArticleBase and ArticleSubsection classes for managing hierarchical document components."""
 
 from itertools import chain
-from typing import Generator, List, Self, Tuple
+from typing import Generator, List, Self, Tuple, override
 
 from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
     ArticleBase,
-    ArticleMainBase,
+    ArticleOutlineBase,
     ArticleRef,
     ChapterBase,
     SectionBase,
@@ -32,22 +32,19 @@ class Paragraph(CensoredAble):
     """List of sentences forming the paragraph's content."""
 
 
-class ArticleSubsection(ArticleMainBase, SubSectionBase):
+class ArticleSubsection(ArticleOutlineBase, SubSectionBase):
     """Atomic argumentative unit with technical specificity."""
 
     paragraphs: List[Paragraph]
     """List of Paragraph objects containing the content of the subsection."""
 
-    def resolve_update_error(self, other: Self) -> str:
-        """Resolve update errors in the article outline."""
-        if self.title != other.title:
-            return f"Title `{other.title}` mismatched, expected `{self.title}`. "
-        return ""
-
-    def _update_from_inner(self, other: Self) -> Self:
+    def update_from_inner(self, other: Self) -> Self:
         """Updates the current instance with the attributes of another instance."""
         logger.debug(f"Updating SubSection {self.title}")
-        self.paragraphs = other.paragraphs
+        SubSectionBase.update_from(self, other)
+        ArticleOutlineBase.update_from(self, other)
+        self.paragraphs.clear()
+        self.paragraphs.extend(other.paragraphs)
         return self
 
     def to_typst_code(self) -> str:
@@ -59,77 +56,23 @@ class ArticleSubsection(ArticleMainBase, SubSectionBase):
         return f"=== {self.title}\n" + "\n\n".join("".join(p.sentences) for p in self.paragraphs)
 
 
-class ArticleSection(ArticleMainBase, SectionBase[ArticleSubsection]):
+class ArticleSection(ArticleOutlineBase, SectionBase[ArticleSubsection]):
     """Atomic argumentative unit with high-level specificity."""
 
-    def resolve_update_error(self, other: Self) -> str:
-        """Resolve update errors in the article outline."""
-        if (s_len := len(self.subsections)) == 0:
-            return ""
-
-        if s_len != len(other.subsections):
-            return f"Subsections length mismatched, expected {len(self.subsections)}, got {len(other.subsections)}"
-
-        sub_sec_err_seq = [
-            out for s, o in zip(self.subsections, other.subsections, strict=True) if (out := s.resolve_update_error(o))
-        ]
-
-        if sub_sec_err_seq:
-            return "\n".join(sub_sec_err_seq)
-        return ""
-
-    def _update_from_inner(self, other: Self) -> Self:
-        """Updates the current instance with the attributes of another instance."""
-        if len(self.subsections) == 0:
-            self.subsections = other.subsections
-            return self
-
-        for self_subsec, other_subsec in zip(self.subsections, other.subsections, strict=True):
-            self_subsec.update_from(other_subsec)
-        return self
-
-    def to_typst_code(self) -> str:
-        """Converts the section into a Typst formatted code snippet.
-
-        Returns:
-            str: The formatted Typst code snippet.
-        """
-        return f"== {self.title}\n" + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
 
 
-class ArticleChapter(ArticleMainBase, ChapterBase[ArticleSection]):
+class ArticleChapter(ArticleOutlineBase, ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
-    def resolve_update_error(self, other: Self) -> str:
-        """Resolve update errors in the article outline."""
-        if (s_len := len(self.sections)) == 0:
-            return ""
-
-        if s_len != len(other.sections):
-            return f"Sections length mismatched, expected {len(self.sections)}, got {len(other.sections)}"
-        sec_err_seq = [
-            out for s, o in zip(self.sections, other.sections, strict=True) if (out := s.resolve_update_error(o))
-        ]
-        if sec_err_seq:
-            return "\n".join(sec_err_seq)
-        return ""
-
-    def _update_from_inner(self, other: Self) -> Self:
-        """Updates the current instance with the attributes of another instance."""
-        if len(self.sections) == 0:
-            self.sections = other.sections
-            return self
-
-        for self_sec, other_sec in zip(self.sections, other.sections, strict=True):
-            self_sec.update_from(other_sec)
-        return self
 
-    def to_typst_code(self) -> str:
-        """Converts the chapter into a Typst formatted code snippet for rendering."""
-        return f"= {self.title}\n" + "\n\n".join(sec.to_typst_code() for sec in self.sections)
 
-
-class Article(Display, CensoredAble, WithRef[ArticleOutline], PersistentAble, ArticleBase[ArticleChapter]):
+class Article(
+    Display,
+    CensoredAble,
+    WithRef[ArticleOutline],
+    PersistentAble,
+    ArticleBase[ArticleChapter],
+):
     """Represents a complete academic paper specification, incorporating validation constraints.
 
     This class integrates display, censorship processing, article structure referencing, and persistence capabilities,
@@ -189,30 +132,24 @@ class Article(Display, CensoredAble, WithRef[ArticleOutline], PersistentAble, Ar
             article.chapters.append(article_chapter)
         return article
 
-    def iter_dfs(self) -> Generator[ArticleMainBase, None, None]:
-        """Performs a depth-first search (DFS) through the article structure.
-
-        Returns:
-            Generator[ArticleMainBase]: Each component in the article structure.
-        """
-        for chap in self.chapters:
-            for sec in chap.sections:
-                yield from sec.subsections
-                yield sec
-            yield chap
-
-    def deref(self, ref: ArticleRef) -> ArticleMainBase:
+    @override
+    def iter_dfs(
+        self,
+    ) -> Generator[ArticleChapter | ArticleSection | ArticleSubsection, None, None]:
+        return super().iter_dfs()
+        
+    def deref(self, ref: ArticleRef) -> ArticleOutlineBase:
         """Resolves a reference to the corresponding section or subsection in the article.
 
         Args:
             ref (ArticleRef): The reference to resolve.
 
         Returns:
-            ArticleMainBase: The corresponding section or subsection.
+            ArticleOutlineBase: The corresponding section or subsection.
         """
         return ok(ref.deref(self), f"{ref} not found in {self.title}")
 
-    def gather_dependencies(self, article: ArticleMainBase) -> List[ArticleMainBase]:
+    def gather_dependencies(self, article: ArticleOutlineBase) -> List[ArticleOutlineBase]:
         """Gathers dependencies for all sections and subsections in the article.
 
         This method should be called after the article is fully constructed.
@@ -226,11 +163,11 @@ class Article(Display, CensoredAble, WithRef[ArticleOutline], PersistentAble, Ar
 
         return list(set(depends + supports))
 
-    def gather_dependencies_recursive(self, article: ArticleMainBase) -> List[ArticleMainBase]:
+    def gather_dependencies_recursive(self, article: ArticleOutlineBase) -> List[ArticleOutlineBase]:
         """Gathers all dependencies recursively for the given article.
 
         Args:
-            article (ArticleMainBase): The article to gather dependencies for.
+            article (ArticleOutlineBase): The article to gather dependencies for.
 
         Returns:
             List[ArticleBase]: A list of all dependencies for the given article.
@@ -269,7 +206,7 @@ class Article(Display, CensoredAble, WithRef[ArticleOutline], PersistentAble, Ar
 
     def iter_dfs_with_deps(
         self, chapter: bool = True, section: bool = True, subsection: bool = True
-    ) -> Generator[Tuple[ArticleMainBase, List[ArticleMainBase]], None, None]:
+    ) -> Generator[Tuple[ArticleOutlineBase, List[ArticleOutlineBase]], None, None]:
         """Iterates through the article in a depth-first manner, yielding each component and its dependencies.
 
         Args:

fabricatio/models/extra/article_outline.py

@@ -1,6 +1,6 @@
 """A module containing the ArticleOutline class, which represents the outline of an academic paper."""
 
-from typing import Generator, List, Optional, Tuple, Union
+from typing import Generator, List, Optional, Self, Tuple, Union, override
 
 import regex
 from fabricatio.models.extra.article_base import (
@@ -19,12 +19,26 @@ class ArticleSubsectionOutline(ArticleOutlineBase, SubSectionBase):
     """Atomic research component specification for academic paper generation."""
 
 
+
 class ArticleSectionOutline(ArticleOutlineBase, SectionBase[ArticleSubsectionOutline]):
-    """A slightly more detailed research component specification for academic paper generation."""
+    """A slightly more detailed research component specification for academic paper generation, Must contain subsections."""
+
+
+    def update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        super().update_from_inner(other)
+        super(ArticleOutlineBase, self).update_from_inner(other)
+        return self
 
 
 class ArticleChapterOutline(ArticleOutlineBase, ChapterBase[ArticleSectionOutline]):
-    """Macro-structural unit implementing standard academic paper organization."""
+    """Macro-structural unit implementing standard academic paper organization. Must contain sections."""
+
+    def update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        super().update_from_inner(other)
+        super(ArticleOutlineBase, self).update_from_inner(other)
+        return self
 
 
 class ArticleOutline(
@@ -34,7 +48,7 @@ class ArticleOutline(
     PersistentAble,
     ArticleBase[ArticleChapterOutline],
 ):
-    """Complete academic paper blueprint with hierarchical validation."""
+    """A class representing the outline of an academic paper."""
 
     abstract: str
     """The abstract is a concise summary of the academic paper's main findings."""
@@ -82,26 +96,16 @@ class ArticleOutline(
                     lines.append(f"=== {i}.{j}.{k} {subsection.title}")
         return "\n".join(lines)
 
-    def iter_dfs(self) -> Generator[ArticleOutlineBase, None, None]:
-        """Iterates through the article outline in a depth-first manner.
+    @override
+    def iter_dfs(
+        self,
+    ) -> Generator[ArticleChapterOutline | ArticleSectionOutline | ArticleSubsectionOutline, None, None]: 
+        return super().iter_dfs()
+    def find_illegal(self) -> Optional[Tuple[ArticleOutlineBase, str]]:
+        """Finds the first illegal component in the outline.
 
         Returns:
-            ArticleOutlineBase: Each component in the article outline.
-        """
-        for chapter in self.chapters:
-            for section in chapter.sections:
-                yield from section.subsections
-                yield section
-            yield chapter
-
-    def resolve_ref_error(self) -> str:
-        """Resolve reference errors in the article outline.
-
-        Returns:
-            str: Error message indicating reference errors in the article outline.
-
-        Notes:
-            This function is designed to find all invalid `ArticleRef` objs in `depend_on` and `support_to` fields, which will be added to the final error summary.
+            Tuple[ArticleOutlineBase, str]: A tuple containing the illegal component and an error message.
         """
         summary = ""
         for component in self.iter_dfs():
@@ -111,8 +115,10 @@ class ArticleOutline(
             for ref in component.support_to:
                 if not ref.deref(self):
                     summary += f"Invalid internal reference in {component.__class__.__name__} titled `{component.title}` at `support_to` field, because the referred {ref.referring_type} is not exists within the article, see the original obj dump: {ref.model_dump()}\n"
-
-        return summary
+            summary += component.introspect()
+            if summary:
+                return component, summary
+        return None
 
     @classmethod
     def from_typst_code(

fabricatio/models/generic.py

@@ -95,7 +95,7 @@ class WithRef[T](Base):
         """Get the referenced object."""
         return ok(self._reference, "_reference is None")
 
-    def update_ref[S](self: S, reference: T | S) -> S:  # noqa: PYI019
+    def update_ref[S: "WithRef"](self: S, reference: T | S) -> S:  # noqa: PYI019
         """Update the reference of the object."""
         if isinstance(reference, self.__class__):
             self._reference = reference.referenced
@@ -139,6 +139,61 @@ class PersistentAble(Base):
         return self.model_validate_json(Path(path).read_text(encoding="utf-8"))
 
 
+class ModelHash(Base):
+    """Class that provides a hash value for the object."""
+
+    def __hash__(self) -> int:
+        """Calculates a hash value for the ArticleBase object based on its model_dump_json representation."""
+        return hash(self.model_dump_json())
+
+
+class UpdateFrom(Base):
+    """Class that provides a method to update the object from another object."""
+
+    def update_pre_check(self, other: Self) -> Self:
+        """Pre-check for updating the object from another object."""
+        if not isinstance(other, self.__class__):
+            raise TypeError(f"Cannot update from a non-{self.__class__.__name__} instance.")
+
+        return self
+
+    @abstractmethod
+    def update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+
+    @final
+    def update_from(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        return self.update_pre_check(other).update_from_inner(other)
+
+
+class ResolveUpdateConflict(Base):
+    """Class that provides a method to update the object from another object."""
+
+    @abstractmethod
+    def resolve_update_conflict(self, other: Self) -> str:
+        """Resolve the update conflict between two objects.
+
+        Args:
+            other (Self): The other object to resolve the update conflict with.
+
+        Returns:
+            str: The resolved update conflict.
+        """
+
+
+class Introspect(Base):
+    """Class that provides a method to introspect the object."""
+
+    @abstractmethod
+    def introspect(self) -> str:
+        """Internal introspection of the object.
+
+        Returns:
+            str: The internal introspection of the object.
+        """
+
+
 class WithBriefing(Named, Described):
     """Class that provides a briefing based on the name and description."""
 
@@ -392,7 +447,7 @@ class PrepareVectorization(Base):
         """
         max_length = max_length or configs.embedding.max_sequence_length
         chunk = self._prepare_vectorization_inner()
-        if len(chunk) > max_length:
+        if max_length and len(chunk) > max_length:
             logger.error(err := f"Chunk exceeds maximum sequence length {max_length}.")
             raise ValueError(err)
 
@@ -475,7 +530,7 @@ class ScopedConfig(Base):
         """Fallback to another instance's attribute values if the current instance's attributes are None.
 
         Args:
-            other (LLMUsage): Another instance from which to copy attribute values.
+            other (ScopedConfig): Another instance from which to copy attribute values.
 
         Returns:
             Self: The current instance, allowing for method chaining.
@@ -495,7 +550,7 @@ class ScopedConfig(Base):
         """Hold to another instance's attribute values if the current instance's attributes are None.
 
         Args:
-            others (LLMUsage | Iterable[LLMUsage]): Another instance or iterable of instances from which to copy attribute values.
+            others (Union[ScopedConfig, Iterable[ScopedConfig]]): Another instance or iterable of instances from which to copy attribute values.
 
         Returns:
             Self: The current instance, allowing for method chaining.

{fabricatio-0.2.7.dev4.dist-info → fabricatio-0.2.7.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.7.dev4
+Version: 0.2.7.dev5
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.7.dev4.dist-info → fabricatio-0.2.7.dev5.dist-info}/RECORD

@@ -1,7 +1,7 @@
-fabricatio-0.2.7.dev4.dist-info/METADATA,sha256=DshHoi8eegFUNjltQNJgm0SkKSGCLPYJj-oaBBlth9o,5259
-fabricatio-0.2.7.dev4.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
-fabricatio-0.2.7.dev4.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
-fabricatio/actions/article.py,sha256=AgxNKIRLXF9T-TdrhLPE8NWmT8QZXz1QvFnouvuoRBc,7684
+fabricatio-0.2.7.dev5.dist-info/METADATA,sha256=ANxpgCb6nTOneCJ-RdQ7ejNoefGzRdKyfQIvwVfCJiU,5259
+fabricatio-0.2.7.dev5.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
+fabricatio-0.2.7.dev5.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/article.py,sha256=cv1pyGOvgMVMaHJqVDKY6h5_u1XtVw3lzJCDFqx4aoc,8073
 fabricatio/actions/article_rag.py,sha256=PiOFxI6VTmLXm3BK-01g_KH1mTE9uOtnA-CwUjt16AU,1456
 fabricatio/actions/output.py,sha256=K7xsBH8MjXRH6JOy3ZO94KCQzX2jNrwPPK_rRXVkS0E,1161
 fabricatio/actions/rag.py,sha256=QBdzEM8MloM_ahx5pTBZAETm9_631lTe_0ih_he_Iuo,2759
@@ -20,12 +20,12 @@ fabricatio/fs/__init__.py,sha256=PCf0s_9KDjVfNw7AfPoJzGt3jMq4gJOfbcT4pb0D0ZY,588
 fabricatio/journal.py,sha256=stnEP88aUBA_GmU9gfTF2EZI8FS2OyMLGaMSTgK4QgA,476
 fabricatio/models/action.py,sha256=UlflniS__MMrUXglu_U3PDFAtKEjVsKEix17AT9oP3M,8769
 fabricatio/models/events.py,sha256=QvlnS8FEELg6KNabcJMeh2GV_y0ZBzKOPphcteKYWYU,4183
-fabricatio/models/extra/article_base.py,sha256=9zkS89G3L9moc0iYNq9D7DCcv0K52jRQWjM1MUK__dg,8449
+fabricatio/models/extra/article_base.py,sha256=Y4ZdC1yabs7jCNKwc-P8GpAJShGJx7EcLyhXuJ194Fo,11469
 fabricatio/models/extra/article_essence.py,sha256=DUESuK4CGgkRvIMoJCv4l8MNp5MawRYoNOtLCrFRPXY,9229
-fabricatio/models/extra/article_main.py,sha256=yhgZvHWAgL-BJ-eolaXTqBzyWq340GfJucoTY_2CPzs,11342
-fabricatio/models/extra/article_outline.py,sha256=83hFbCaUDuXn9K_0qcCXQOQ1NBmK-7305ChfKvhNXns,7404
+fabricatio/models/extra/article_main.py,sha256=l6HO3PajaesEET6Evd2A7OOpHRelGYr4y88JyoPmP3Y,8498
+fabricatio/models/extra/article_outline.py,sha256=VV6RUY7VzKwqCXoykDi-vL2nqHouOuo1Q3hLdCdNDpQ,7740
 fabricatio/models/extra/article_proposal.py,sha256=p0NPzqg9x6t65DZqdF52Z1P0JwP6kwo2_eP-NsXgifU,1720
-fabricatio/models/generic.py,sha256=GVjcDnzwjKElCZoEVciS7X8SSPjqEp_6M2fLiyAkwNo,17644
+fabricatio/models/generic.py,sha256=yEpP4cvvmB0sDbs36pIl2KYFsnNRKq7V0m3HqoSQc7o,19492
 fabricatio/models/kwargs_types.py,sha256=chJ-rHaeBVRUPuORHuGR3DdNxxTUrotz0eflPEh4l4w,5474
 fabricatio/models/role.py,sha256=mmQbJ6GKr2Gx3wtjEz8d-vYoXs09ffcEkT_eCXaDd3E,2782
 fabricatio/models/task.py,sha256=8NaR7ojQWyM740EDTqt9stwHKdrD6axCRpLKo0QzS-I,10492
@@ -42,6 +42,6 @@ fabricatio/workflows/rag.py,sha256=-YYp2tlE9Vtfgpg6ROpu6QVO8j8yVSPa6yDzlN3qVxs,5
 fabricatio/_rust.pyi,sha256=dGTGV7viu3YAGl1cRKIWrdHPc1hlwk3_hbaDaswxdVo,3831
 fabricatio/_rust_instances.py,sha256=2GwF8aVfYNemRI2feBzH1CZfBGno-XJJE5imJokGEYw,314
 fabricatio/__init__.py,sha256=SzBYsRhZeL77jLtfJEjmoHOSwHwUGyvMATX6xfndLDM,1135
-fabricatio/_rust.cp312-win_amd64.pyd,sha256=opsv_4PpUw06LsJqoKuuTr8aQ3NdAMxB1Ep2RrQqaLc,1835520
-fabricatio-0.2.7.dev4.data/scripts/tdown.exe,sha256=eEr8wBSNDWdntRBBly7YQr1DnA0ru8NAgAmfMPw7SdU,3402240
-fabricatio-0.2.7.dev4.dist-info/RECORD,,
+fabricatio/_rust.cp312-win_amd64.pyd,sha256=db4DHfetEQMNh7hqmL6All-asJooQxFIIXZkoWKAx4c,1835008
+fabricatio-0.2.7.dev5.data/scripts/tdown.exe,sha256=xZcDsLIn9rJZcM8iDNgS-eNK4ckH5rufC6mU6I2vmOo,3399680
+fabricatio-0.2.7.dev5.dist-info/RECORD,,