fabricatio 0.2.7.dev5__cp312-cp312-win_amd64.whl → 0.2.8.dev0__cp312-cp312-win_amd64.whl

fabricatio/actions/article.py

@@ -1,5 +1,6 @@
 """Actions for transmitting tasks to targets."""
 
+from asyncio import gather
 from pathlib import Path
 from typing import Any, Callable, List, Optional
 
@@ -55,13 +56,14 @@ class GenerateArticleProposal(Action):
         task_input: Optional[Task] = None,
         article_briefing: Optional[str] = None,
         article_briefing_path: Optional[str] = None,
+        langauge: Optional[str] = None,
         **_,
     ) -> Optional[ArticleProposal]:
         if article_briefing is None and article_briefing_path is None and task_input is None:
             logger.error("Task not approved, since all inputs are None.")
             return None
 
-        return ok(
+        proposal = ok(
             await self.propose(
                 ArticleProposal,
                 briefing := (
@@ -78,8 +80,12 @@ class GenerateArticleProposal(Action):
                 ),
                 **self.prepend_sys_msg(),
             ),
-            "Could not generate the proposal."
+            "Could not generate the proposal.",
         ).update_ref(briefing)
+        if langauge:
+            proposal.language = langauge
+
+        return proposal
 
 
 class GenerateOutline(Action):
@@ -102,27 +108,92 @@ class GenerateOutline(Action):
             "Could not generate the outline.",
         )
 
-        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."
+        introspect_manual = ok(
+            await self.draft_rating_manual(
+                topic=(
+                    intro_topic
+                    := "Fix the error in the article outline, make sure there is no more error in the article outline."
+                ),
             ),
-        ),"Could not generate the rating manual.")
+            "Could not generate the rating manual.",
+        )
 
-        while pack := out.find_illegal():
+        while pack := out.find_introspected():
             component, err = ok(pack)
-            logger.warning(f"Found error in the outline: \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.")
+            logger.warning(f"Found introspected error: {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=intro_topic,
+                    rating_manual=introspect_manual,
+                    supervisor_check=False,
+                ),
+                "Could not correct the component.",
+            )
             component.update_from(corrected)
+
+        ref_manual = ok(
+            await self.draft_rating_manual(
+                topic=(
+                    ref_topic
+                    := "Fix the internal referring error, make sure there is no more `ArticleRef` pointing to a non-existing article component."
+                ),
+            ),
+            "Could not generate the rating manual.",
+        )
+
+        while pack := out.find_illegal_ref():
+            ref, err = ok(pack)
+            logger.warning(f"Found illegal referring error: {err}")
+            ok(
+                await self.correct_obj_inplace(
+                    ref,
+                    reference=f"# Original Article Outline\n{out.display()}\n# Error Need to be fixed\n{err}\n\n",
+                    topic=ref_topic,
+                    rating_manual=ref_manual,
+                    supervisor_check=False,
+                )
+            )
         return out.update_ref(article_proposal)
 
 
+class GenerateArticle(Action):
+    """Generate the article based on the outline."""
+
+    output_key: str = "article"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        article_outline: ArticleOutline,
+        **_,
+    ) -> Optional[Article]:
+        article: Article = Article.from_outline(ok(article_outline, "Article outline not specified.")).update_ref(
+            article_outline
+        )
+
+        write_para_manual = ok(
+            await self.draft_rating_manual(w_topic := "write the following paragraph in the subsection.")
+        )
+
+        await gather(
+            *[
+                self.correct_obj_inplace(
+                    subsec,
+                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
+                    topic=w_topic,
+                    rating_manual=write_para_manual,
+                    supervisor_check=False,
+                )
+                for _, __, subsec in article.iter_subsections()
+                if (err := subsec.introspect())
+            ],
+            return_exceptions=True,
+        )
+        return article
+
+
 class CorrectProposal(Action):
     """Correct the proposal of the article."""
 
@@ -150,60 +221,6 @@ class CorrectOutline(Action):
         )
 
 
-class GenerateArticle(Action):
-    """Generate the article based on the outline."""
-
-    output_key: str = "article"
-    """The key of the output data."""
-
-    async def _execute(
-        self,
-        article_outline: ArticleOutline,
-        **_,
-    ) -> Optional[Article]:
-        article: Article = Article.from_outline(article_outline).update_ref(article_outline)
-
-        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 = 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()}")
-
-            out = ok(
-                await self.correct_obj(
-                    c,
-                    reference=(
-                        ref := f"{article_outline.referenced.as_prompt()}\n" + "\n".join(d.display() for d in deps)
-                    ),
-                    topic=topic_1,
-                    rating_manual=writing_manual,
-                    supervisor_check=False,
-                ),
-                "Could not correct the article component.",
-            )
-            while err := c.resolve_update_conflict(out):
-                logger.warning(f"Found error in the article component: \n{err}")
-                out = ok(
-                    await self.correct_obj(
-                        out,
-                        reference=f"{ref}\n\n# Violated Error\n{err}",
-                        topic=topic_2,
-                        rating_manual=err_resolve_manual,
-                        supervisor_check=False,
-                    ),
-                    "Could not correct the article component.",
-                )
-
-            c.update_from(out)
-        return article
-
-
 class CorrectArticle(Action):
     """Correct the article based on the outline."""
 

fabricatio/actions/output.py

@@ -3,8 +3,9 @@
 from pathlib import Path
 from typing import Optional
 
+from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.generic import FinalizedDumpAble
+from fabricatio.models.generic import FinalizedDumpAble, PersistentAble
 from fabricatio.models.task import Task
 from fabricatio.models.utils import ok
 
@@ -32,3 +33,37 @@ class DumpFinalizedOutput(Action):
         )
         ok(to_dump, "Could not dump the data since the path is not specified.").finalized_dump_to(dump_path)
         return dump_path.as_posix()
+
+
+class PersistentAll(Action):
+    """Persist all the data to a file."""
+
+    output_key: str = "persistent_count"
+
+    async def _execute(
+        self,
+        task_input: Optional[Task] = None,
+        persist_dir: Optional[str | Path] = None,
+        **cxt,
+    ) -> int:
+        persist_dir = Path(
+            persist_dir
+            or ok(
+                await self.awhich_pathstr(
+                    f"{ok(task_input, 'Neither `task_input` and `dump_path` is provided.').briefing}\n\nExtract a single path of the file, to which I will persist the data."
+                ),
+                "Can not find the path of file to persist the data.",
+            )
+        )
+
+        count = 0
+        if persist_dir.is_file():
+            logger.warning("Dump should be a directory, but it is a file. Skip dumping.")
+            return count
+        persist_dir.mkdir(parents=True, exist_ok=True)
+        for v in cxt.values():
+            if isinstance(v, PersistentAble):
+                v.persist(persist_dir)
+                count += 1
+
+        return count

fabricatio/capabilities/correct.py

@@ -10,7 +10,7 @@ from typing import Optional, Unpack, cast
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.review import Review, ReviewResult
 from fabricatio.config import configs
-from fabricatio.models.generic import CensoredAble, Display, ProposedAble, WithBriefing
+from fabricatio.models.generic import CensoredAble, Display, ProposedAble, ProposedUpdateAble, WithBriefing
 from fabricatio.models.kwargs_types import CensoredCorrectKwargs, CorrectKwargs, ReviewKwargs
 from fabricatio.models.task import Task
 from questionary import confirm, text
@@ -134,12 +134,32 @@ class Correct(Review):
         while await confirm("Begin to correct obj above with human censorship?").ask_async():
             while (topic := await text("What is the topic of the obj reviewing?").ask_async()) is not None and topic:
                 ...
-            if (modified_obj := await self.correct_obj(
-                last_modified_obj,
-                topic=topic,
-                **kwargs,
-            )) is None:
+            if (
+                modified_obj := await self.correct_obj(
+                    last_modified_obj,
+                    topic=topic,
+                    **kwargs,
+                )
+            ) is None:
                 break
             last_modified_obj = modified_obj
             rprint(last_modified_obj.finalized_dump())
         return modified_obj or last_modified_obj
+
+    async def correct_obj_inplace[M: ProposedUpdateAble](
+        self, obj: M, **kwargs: Unpack[CorrectKwargs[ReviewResult[str]]]
+    ) -> Optional[M]:
+        """Correct an object in place based on defined criteria and templates.
+
+        Args:
+            obj (M): The object to be corrected.
+            **kwargs (Unpack[CensoredCorrectKwargs]): Additional keyword arguments for the correction process.
+
+        Returns:
+            Optional[M]: The corrected object, or None if correction fails.
+        """
+        corrected_obj = await self.correct_obj(obj, **kwargs)
+        if corrected_obj is None:
+            return corrected_obj
+        obj.update_from(corrected_obj)
+        return obj

fabricatio/models/action.py

@@ -170,6 +170,8 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
                 # Update context with modified values
                 modified_ctx = await act_task
                 logger.success(f"Step execution finished: {current_action}")
+                if step.output_key:
+                    logger.success(f"Setting output: {step.output_key}")
                 await self._context.put(modified_ctx)
 
             logger.success(f"Workflow execution finished: {self.name}")

fabricatio/models/extra/article_base.py

@@ -1,24 +1,22 @@
 """A foundation for hierarchical document components with dependency tracking."""
-from abc import ABC
+
+from abc import abstractmethod
 from enum import StrEnum
-from typing import TYPE_CHECKING, Generator, List, Optional, Self, Union, overload
+from functools import cache
+from itertools import chain
+from typing import Generator, List, Optional, Self, Tuple
 
 from fabricatio.models.generic import (
-    Base,
     CensoredAble,
     Display,
+    FinalizedDumpAble,
     Introspect,
     ModelHash,
     PersistentAble,
-    ProposedAble,
+    ProposedUpdateAble,
     ResolveUpdateConflict,
-    UpdateFrom,
 )
 
-if TYPE_CHECKING:
-    from fabricatio.models.extra.article_main import Article
-    from fabricatio.models.extra.article_outline import ArticleOutline
-
 
 class ReferringType(StrEnum):
     """Enumeration of different types of references that can be made in an article."""
@@ -28,7 +26,11 @@ class ReferringType(StrEnum):
     SUBSECTION = "subsection"
 
 
-class ArticleRef(CensoredAble):
+type RefKey = Tuple[str, Optional[str], Optional[str]]
+
+
+@cache
+class ArticleRef(CensoredAble, Display, ProposedUpdateAble):
     """Reference to a specific chapter, section or subsection within the article. You SHALL not refer to an article component that is external and not present within our own article.
 
     Examples:
@@ -61,30 +63,21 @@ class ArticleRef(CensoredAble):
             ```
     """
 
-    referred_subsection_title: Optional[str] = None
-    """`title` Field of the referenced subsection."""
-
-    referred_section_title: Optional[str] = None
-    """`title` Field of the referenced section."""
-
     referred_chapter_title: str
     """`title` Field of the referenced chapter"""
+    referred_section_title: Optional[str] = None
+    """`title` Field of the referenced section."""
+    referred_subsection_title: Optional[str] = None
+    """`title` Field of the referenced subsection."""
 
-    def __hash__(self) -> int:
-        """Overrides the default hash function to ensure consistent hashing across instances."""
-        return hash((self.referred_chapter_title, self.referred_section_title, self.referred_subsection_title))
-
-    @overload
-    def deref(self, article: "Article") -> Optional["ArticleMainBase"]:
-        """Dereference the reference to the actual section or subsection within the provided article."""
-
-    @overload
-    def deref(self, article: "ArticleOutline") -> Optional["ArticleOutlineBase"]:
-        """Dereference the reference to the actual section or subsection within the provided article."""
+    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
+        return self
 
-    def deref(
-        self, article: Union["ArticleOutline", "Article"]
-    ) -> Union["ArticleOutlineBase", "ArticleMainBase", None]:
+    def deref(self, article: "ArticleBase") -> Optional["ArticleOutlineBase"]:
         """Dereference the reference to the actual section or subsection within the provided article.
 
         Args:
@@ -111,21 +104,70 @@ class ArticleRef(CensoredAble):
         return ReferringType.CHAPTER
 
 
-class SubSectionBase(
-    UpdateFrom,
+class ArticleMetaData(CensoredAble, Display):
+    """Metadata for an article component."""
+
+    description: str
+    """Description of the research component in academic style."""
+
+    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."""
+
+    writing_aim: 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."""
+
+
+class ArticleOutlineBase(
+    ArticleMetaData,
+    ResolveUpdateConflict,
+    ProposedUpdateAble,
+    PersistentAble,
+    ModelHash,
     Introspect,
 ):
-    """Base class for article sections and subsections."""
+    """Base class for article outlines."""
 
-    title: str
-    """Title of the subsection, do not add any prefix or suffix to the title. should not contain special characters."""
+    @property
+    def metadata(self) -> ArticleMetaData:
+        """Returns the metadata of the article component."""
+        return ArticleMetaData.model_validate(self, from_attributes=True)
 
+    def update_metadata(self, other: ArticleMetaData) -> Self:
+        """Updates the metadata of 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
+
+    def display_metadata(self) -> str:
+        """Displays the metadata of the current instance."""
+        return self.model_dump_json(
+            indent=1, include={"title", "writing_aim", "description", "support_to", "depend_on"}
+        )
+
+    def update_from_inner(self, other: Self) -> Self:
+        """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."""
-        return f"=== {self.title}\n"
 
-    def update_from_inner(self, other: Self) -> Self:
-        return self
+
+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"
 
     def introspect(self) -> str:
         """Introspects the article subsection outline."""
@@ -138,16 +180,11 @@ class SubSectionBase(
         return ""
 
 
-class SectionBase[T: SubSectionBase](
-    UpdateFrom,
-    Introspect,
-):
+class SectionBase[T: SubSectionBase](ArticleOutlineBase):
     """Base class for article sections and subsections."""
 
     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.
@@ -174,6 +211,7 @@ class SectionBase[T: SubSectionBase](
 
     def update_from_inner(self, other: Self) -> Self:
         """Updates the current instance with the attributes of another instance."""
+        super().update_from_inner(other)
         if len(self.subsections) == 0:
             self.subsections = other.subsections
             return self
@@ -189,16 +227,12 @@ class SectionBase[T: SubSectionBase](
         return ""
 
 
-class ChapterBase[T: SectionBase](
-    UpdateFrom,
-    Introspect,
-):
+class ChapterBase[T: SectionBase](ArticleOutlineBase):
     """Base class for article chapters."""
 
     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 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)
@@ -233,21 +267,35 @@ class ChapterBase[T: SectionBase](
         return ""
 
 
-class ArticleBase[T: ChapterBase](Base):
+class ArticleBase[T: ChapterBase](FinalizedDumpAble):
     """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
+    """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."""
-    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(
+    def iter_dfs_rev(
         self,
-    ) -> Generator[ChapterBase | SectionBase | SubSectionBase, None, None]:
-        """Performs a depth-first search (DFS) through the article structure.
+    ) -> Generator[ArticleOutlineBase, None, None]:
+        """Performs a depth-first search (DFS) through the article structure in reverse order.
 
         Returns:
-            Generator[ArticleMainBase]: Each component in the article structure.
+            Generator[ArticleMainBase]: Each component in the article structure in reverse order.
         """
         for chap in self.chapters:
             for sec in chap.sections:
@@ -255,37 +303,80 @@ class ArticleBase[T: ChapterBase](Base):
                 yield sec
             yield chap
 
+    def iter_dfs(self) -> Generator[ArticleOutlineBase, None, None]:
+        """Performs a depth-first search (DFS) through the article structure.
 
-class ArticleOutlineBase(
-    CensoredAble,
-    UpdateFrom,
-    ResolveUpdateConflict,
-    ProposedAble,
-    PersistentAble,
-    Display,
-    ModelHash,
-    ABC,
-):
-    """Base class for article outlines."""
+        Returns:
+            Generator[ArticleMainBase]: Each component in the article structure.
+        """
+        for chap in self.chapters:
+            yield chap
+            for sec in chap.sections:
+                yield sec
+                yield from sec.subsections
 
-    description: str
-    """Description of the research component in academic style."""
+    def iter_sections(self) -> Generator[Tuple[ChapterBase, SectionBase], None, None]:
+        """Iterates through all sections in the article.
 
-    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."""
+        Returns:
+            Generator[ArticleOutlineBase]: Each section in the article.
+        """
+        for chap in self.chapters:
+            for sec in chap.sections:
+                yield chap, sec
 
-    writing_aim: List[str]
-    """List of writing aims of the research component in academic style."""
+    def iter_subsections(self) -> Generator[Tuple[ChapterBase, SectionBase, SubSectionBase], None, None]:
+        """Iterates through all subsections in the article.
 
-    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
+        Returns:
+            Generator[ArticleOutlineBase]: Each subsection in the article.
+        """
+        for chap, sec in self.iter_sections():
+            for subsec in sec.subsections:
+                yield chap, sec, subsec
+
+    def find_introspected(self) -> Optional[Tuple[ArticleOutlineBase, str]]:
+        """Finds the first introspected component in the article structure."""
+        summary = ""
+        for component in self.iter_dfs_rev():
+            summary += component.introspect()
+            if summary:
+                return component, summary
+        return None
+
+    def find_illegal_ref(self) -> Optional[Tuple[ArticleRef, str]]:
+        """Finds the first illegal component in the outline.
+
+        Returns:
+            Tuple[ArticleOutlineBase, str]: A tuple containing the illegal component and an error message.
+        """
+        summary = ""
+        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:
+                    return ref, summary
+        return None
+
+    def finalized_dump(self) -> str:
+        """Generates standardized hierarchical markup for academic publishing systems.
+
+        Implements ACL 2024 outline conventions with four-level structure:
+        = Chapter Title (Level 1)
+        == Section Title (Level 2)
+        === Subsection Title (Level 3)
+        ==== Subsubsection Title (Level 4)
+
+        Returns:
+            str: Strictly formatted outline with academic sectioning
+
+        Example:
+            = Methodology
+            == Neural Architecture Search Framework
+            === Differentiable Search Space
+            ==== Constrained Optimization Parameters
+            === Implementation Details
+            == Evaluation Protocol
+        """
+        return "\n\n".join(a.to_typst_code() for a in self.chapters)

fabricatio/models/extra/article_main.py

@@ -7,7 +7,6 @@ from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
     ArticleBase,
     ArticleOutlineBase,
-    ArticleRef,
     ChapterBase,
     SectionBase,
     SubSectionBase,
@@ -28,21 +27,26 @@ class Paragraph(CensoredAble):
     writing_aim: List[str]
     """Specific communicative objectives for this paragraph's content."""
 
-    sentences: List[str]
-    """List of sentences forming the paragraph's content."""
+    content: str
+    """The actual content of the paragraph, represented as a string."""
 
 
-class ArticleSubsection(ArticleOutlineBase, SubSectionBase):
+class ArticleSubsection(SubSectionBase):
     """Atomic argumentative unit with technical specificity."""
 
     paragraphs: List[Paragraph]
     """List of Paragraph objects containing the content of the subsection."""
 
+    def introspect(self) -> str:
+        """Introspects the subsection and returns a message if it has no paragraphs."""
+        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 ""
+
     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}")
-        SubSectionBase.update_from(self, other)
-        ArticleOutlineBase.update_from(self, other)
+        super().update_from_inner(other)
         self.paragraphs.clear()
         self.paragraphs.extend(other.paragraphs)
         return self
@@ -53,19 +57,17 @@ class ArticleSubsection(ArticleOutlineBase, SubSectionBase):
         Returns:
             str: Typst code snippet for rendering.
         """
-        return f"=== {self.title}\n" + "\n\n".join("".join(p.sentences) for p in self.paragraphs)
+        return f"=== {self.title}\n" + "\n\n".join(p.content for p in self.paragraphs)
 
 
-class ArticleSection(ArticleOutlineBase, SectionBase[ArticleSubsection]):
+class ArticleSection(SectionBase[ArticleSubsection]):
     """Atomic argumentative unit with high-level specificity."""
 
 
-
-class ArticleChapter(ArticleOutlineBase, ChapterBase[ArticleSection]):
+class ArticleChapter(ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
 
-
 class Article(
     Display,
     CensoredAble,
@@ -79,22 +81,9 @@ class Article(
     aiming to provide a comprehensive model for academic papers.
     """
 
-    abstract: str
-    """Contains a summary of the academic paper."""
-
-    title: str
-    """Represents the title of the academic paper."""
-
-    language: str
-    """Written language of the article. SHALL be aligned to the language of the article outline provided."""
-
-    def finalized_dump(self) -> str:
-        """Exports the article in `typst` format.
-
-        Returns:
-                str: Strictly formatted outline with typst formatting.
-        """
-        return "\n\n".join(c.to_typst_code() for c in self.chapters)
+    @override
+    def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
+        return super().iter_subsections()
 
     @classmethod
     def from_outline(cls, outline: ArticleOutline) -> "Article":
@@ -107,7 +96,7 @@ class Article(
             Article: The generated article.
         """
         # Set the title from the outline
-        article = Article(**outline.model_dump(include={"title", "abstract"}), chapters=[])
+        article = Article(**outline.model_dump(exclude={"chapters"}), chapters=[])
 
         for chapter in outline.chapters:
             # Create a new chapter
@@ -132,33 +121,16 @@ class Article(
             article.chapters.append(article_chapter)
         return article
 
-    @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:
-            ArticleOutlineBase: The corresponding section or subsection.
-        """
-        return ok(ref.deref(self), f"{ref} not found in {self.title}")
-
     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.
         """
-        depends = [self.deref(a) for a in article.depend_on]
+        depends = [ok(a.deref(self)) for a in article.depend_on]
 
         supports = []
-        for a in self.iter_dfs():
-            if article in {self.deref(b) for b in a.support_to}:
+        for a in self.iter_dfs_rev():
+            if article in {ok(b.deref(self)) for b in a.support_to}:
                 supports.append(a)
 
         return list(set(depends + supports))
@@ -220,7 +192,7 @@ class Article(
         if all((not chapter, not section, not subsection)):
             raise ValueError("At least one of chapter, section, or subsection must be True.")
 
-        for component in self.iter_dfs():
+        for component in self.iter_dfs_rev():
             if not chapter and isinstance(component, ArticleChapter):
                 continue
             if not section and isinstance(component, ArticleSection):

fabricatio/models/extra/article_outline.py

@@ -1,45 +1,26 @@
 """A module containing the ArticleOutline class, which represents the outline of an academic paper."""
 
-from typing import Generator, List, Optional, Self, Tuple, Union, override
-
-import regex
 from fabricatio.models.extra.article_base import (
     ArticleBase,
-    ArticleOutlineBase,
     ChapterBase,
     SectionBase,
     SubSectionBase,
 )
 from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.generic import CensoredAble, Display, PersistentAble, WithRef
-from fabricatio.models.utils import ok
 
 
-class ArticleSubsectionOutline(ArticleOutlineBase, SubSectionBase):
+class ArticleSubsectionOutline(SubSectionBase):
     """Atomic research component specification for academic paper generation."""
 
 
-
-class ArticleSectionOutline(ArticleOutlineBase, SectionBase[ArticleSubsectionOutline]):
+class ArticleSectionOutline(SectionBase[ArticleSubsectionOutline]):
     """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]):
+class ArticleChapterOutline(ChapterBase[ArticleSectionOutline]):
     """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(
     Display,
@@ -48,140 +29,4 @@ class ArticleOutline(
     PersistentAble,
     ArticleBase[ArticleChapterOutline],
 ):
-    """A class representing the outline of an academic paper."""
-
-    abstract: str
-    """The abstract is a concise summary of the academic paper's main findings."""
-
-    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
-    """
-
-    title: str
-    """Title of the academic paper."""
-
-    language: str
-    """Written language of the article. SHALL be aligned to the language of the article proposal provided."""
-
-    def finalized_dump(self) -> str:
-        """Generates standardized hierarchical markup for academic publishing systems.
-
-        Implements ACL 2024 outline conventions with four-level structure:
-        = Chapter Title (Level 1)
-        == Section Title (Level 2)
-        === Subsection Title (Level 3)
-        ==== Subsubsection Title (Level 4)
-
-        Returns:
-            str: Strictly formatted outline with academic sectioning
-
-        Example:
-            = Methodology
-            == Neural Architecture Search Framework
-            === Differentiable Search Space
-            ==== Constrained Optimization Parameters
-            === Implementation Details
-            == Evaluation Protocol
-        """
-        lines: List[str] = []
-        for i, chapter in enumerate(self.chapters, 1):
-            lines.append(f"= Chapter {i}: {chapter.title}")
-            for j, section in enumerate(chapter.sections, 1):
-                lines.append(f"== {i}.{j} {section.title}")
-                for k, subsection in enumerate(section.subsections, 1):
-                    lines.append(f"=== {i}.{j}.{k} {subsection.title}")
-        return "\n".join(lines)
-
-    @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:
-            Tuple[ArticleOutlineBase, str]: A tuple containing the illegal component and an error message.
-        """
-        summary = ""
-        for component in self.iter_dfs():
-            for ref in component.depend_on:
-                if not ref.deref(self):
-                    summary += f"Invalid internal reference in {component.__class__.__name__} titled `{component.title}` at `depend_on` field, because the referred {ref.referring_type} is not exists within the article, see the original obj dump: {ref.model_dump()}\n"
-            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"
-            summary += component.introspect()
-            if summary:
-                return component, summary
-        return None
-
-    @classmethod
-    def from_typst_code(
-        cls, typst_code: str, title: str = "", article_language: str = "en", prospect: str = "", abstract: str = ""
-    ) -> "ArticleOutline":
-        """Parses a Typst code string and creates an ArticleOutline instance."""
-        self = cls(language=article_language, prospect=prospect, abstract=abstract, chapters=[], title=title)
-        stack = [self]  # 根节点为ArticleOutline实例
-
-        for line in typst_code.splitlines():
-            parsed = cls._parse_line(line)
-            if not parsed:
-                continue
-            level, title = parsed
-            cls._adjust_stack(stack, level)
-            parent = stack[-1]
-            component = cls._create_component(level, title)
-            cls._add_to_parent(parent, component, level)
-            stack.append(component)
-
-        return self
-
-    @classmethod
-    def _parse_line(cls, line: str) -> Optional[Tuple[int, str]]:
-        stripped = line.strip()
-        if not stripped.startswith("="):
-            return None
-        match = regex.match(r"^(\=+)(.*)", stripped)
-        if not match:
-            return None
-        eqs, title_part = match.groups()
-        return len(eqs), title_part.strip()
-
-    @classmethod
-    def _adjust_stack(cls, stack: List[object], target_level: int) -> None:
-        while len(stack) > target_level:
-            stack.pop()
-
-    @classmethod
-    def _create_component(cls, level: int, title: str) -> ArticleOutlineBase:
-        default_kwargs = {
-            "writing_aim": [],
-            "depend_on": [],
-            "support_to": [],
-            "description": [],
-        }
-        component_map = {
-            1: lambda: ArticleChapterOutline(title=title, sections=[], **default_kwargs),
-            2: lambda: ArticleSectionOutline(title=title, subsections=[], **default_kwargs),
-            3: lambda: ArticleSubsectionOutline(title=title, **default_kwargs),
-        }
-        return ok(component_map.get(level, lambda: None)(), "Invalid level")
-
-    @classmethod
-    def _add_to_parent(
-        cls,
-        parent: Union["ArticleOutline", ArticleChapterOutline, ArticleSectionOutline],
-        component: ArticleOutlineBase,
-        level: int,
-    ) -> None:
-        if level == 1 and isinstance(component, ArticleChapterOutline):
-            parent.chapters.append(component)
-        elif level == 2 and isinstance(component, ArticleSectionOutline):  # noqa: PLR2004
-            parent.sections.append(component)
-        elif level == 3 and isinstance(component, ArticleSubsectionOutline):  # noqa: PLR2004
-            parent.subsections.append(component)
+    """Outline of an academic paper, containing chapters, sections, subsections."""

fabricatio/models/extra/article_proposal.py

@@ -11,25 +11,23 @@ class ArticleProposal(CensoredAble, Display, WithRef[str], AsPrompt, PersistentA
     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."""
+
     technical_approaches: List[str]
-    """Technical approaches"""
+    """A list of technical approaches or methodologies used to solve the research problems."""
 
     research_methods: List[str]
-    """Methodological components (list of techniques/tools).
-    Example: ['Differentiable architecture search', 'Transformer-based search space', 'Multi-lingual perplexity evaluation']"""
+    """A list of methodological components, including techniques and tools utilized in the research."""
 
     research_aim: List[str]
-    """Primary research objectives (list of 2-4 measurable goals).
-    Example: ['Develop parameter-efficient NAS framework', 'Establish cross-lingual architecture transfer metrics']"""
-
-    focused_problem: List[str]
-    """Specific research problem(s) or question(s) addressed (list of 1-3 concise statements).
-    Example: ['NAS computational overhead in low-resource settings', 'Architecture transferability across language pairs']"""
-
-    title: str
-    """Paper title in academic style (Title Case, 8-15 words). Example: 'Exploring Neural Architecture Search for Low-Resource Machine Translation'"""
-    language: str
-    """Written language of the article. SHALL be aligned to the language of the article briefing provided."""
+    """A list of primary research objectives that the paper seeks to achieve."""
 
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {"ArticleBriefing": self.referenced, "ArticleProposal": self.display()}

fabricatio/models/generic.py

@@ -1,6 +1,6 @@
 """This module defines generic classes for models in the Fabricatio library."""
 
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Union, final, overload
 
@@ -108,7 +108,7 @@ class PersistentAble(Base):
     """Class that provides a method to persist the object."""
 
     def persist(self, path: str | Path) -> Self:
-        """Persist the object to a file.
+        """Persist the object to a file or directory.
 
         Args:
             path (str | Path): The path to save the object.
@@ -117,7 +117,7 @@ class PersistentAble(Base):
             Self: The current instance of the object.
         """
         p = Path(path)
-        out = self.model_dump_json()
+        out = self.model_dump_json(indent=1)
         if p.is_dir():
             p.joinpath(f"{self.__class__.__name__}_{blake3_hash(out.encode())[:6]}.json").write_text(
                 out, encoding="utf-8"
@@ -125,6 +125,7 @@ class PersistentAble(Base):
             return self
         p.mkdir(exist_ok=True, parents=True)
         p.write_text(out, encoding="utf-8")
+        logger.info(f"Persisted {self} to {p.as_posix()}")
         return self
 
     def from_persistent(self, path: str | Path) -> Self:
@@ -228,20 +229,11 @@ class WithBriefing(Named, Described):
                 raise TypeError(f"{system_msg_like} is not a dict or str")
 
 
-class ReverseGenerate(GenerateJsonSchema):
+class UnsortGenerate(GenerateJsonSchema):
     """Class that provides a reverse JSON schema of the model."""
 
-    def _sort_recursive(self, value: Any, parent_key: str | None = None) -> Any:
-        if isinstance(value, dict):
-            sorted_dict: dict[str, JsonSchemaValue] = {}
-            # Reverse all keys regardless of parent_key
-            keys = reversed(value.keys())
-            for key in keys:
-                sorted_dict[key] = self._sort_recursive(value[key], parent_key=key)
-            return sorted_dict
-        if isinstance(value, list):
-            # Reverse list order and process each item
-            return [self._sort_recursive(item, parent_key) for item in reversed(value)]
+    def sort(self, value: JsonSchemaValue, parent_key: str | None = None) -> JsonSchemaValue:
+        """Not sort."""
         return value
 
 
@@ -256,7 +248,7 @@ class WithFormatedJsonSchema(Base):
             str: The JSON schema of the model in a formatted string.
         """
         return orjson.dumps(
-            cls.model_json_schema(schema_generator=ReverseGenerate),
+            cls.model_json_schema(schema_generator=UnsortGenerate),
             option=orjson.OPT_INDENT_2,
         ).decode()
 
@@ -316,6 +308,10 @@ class ProposedAble(CreateJsonObjPrompt, InstantiateFromString):
     """Class that provides a method to propose a JSON object based on the requirement."""
 
 
+class ProposedUpdateAble(PersistentAble, UpdateFrom, ABC):
+    """Make the obj can be updated from the proposed obj in place."""
+
+
 class FinalizedDumpAble(Base):
     """Class that provides a method to finalize the dump of the object."""
 

fabricatio/models/usages.py

@@ -1,5 +1,6 @@
 """This module contains classes that manage the usage of language models and tools in tasks."""
 
+import traceback
 from asyncio import gather
 from typing import Callable, Dict, Iterable, List, Optional, Self, Sequence, Set, Type, Union, Unpack, overload
 
@@ -38,6 +39,8 @@ ROUTER = Router(
     allowed_fails=configs.routing.allowed_fails,
     retry_after=configs.routing.retry_after,
     cooldown_time=configs.routing.cooldown_time,
+    cache_responses=configs.cache.enabled,
+    cache_kwargs=configs.cache.params,
 )
 
 
@@ -135,7 +138,7 @@ class LLMUsage(ScopedConfig):
             List[Choices | StreamingChoices]: A list of choices or streaming choices from the model response.
         """
         resp = await self.aquery(
-            messages=Messages().add_system_message(system_message).add_user_message(question),
+            messages=Messages().add_system_message(system_message).add_user_message(question).as_list(),
             n=n,
             **kwargs,
         )
@@ -324,6 +327,7 @@ class LLMUsage(ScopedConfig):
                     continue
                 except Exception as e:  # noqa: BLE001
                     logger.error(f"Error during validation: \n{e}")
+                    logger.debug(traceback.format_exc())
                     break
                 if not kwargs.get("no_cache"):
                     kwargs["no_cache"] = True

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

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

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

@@ -1,11 +1,11 @@
-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-0.2.8.dev0.dist-info/METADATA,sha256=coMH1ZINCPxofmsl4UlmFGMsJRrE_Xx_9fzKOQcKSTY,5259
+fabricatio-0.2.8.dev0.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
+fabricatio-0.2.8.dev0.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/article.py,sha256=2e96lVsk2WR9VsjRc3mE8cOUvEgdhE36kL4x_WxdJWk,8313
 fabricatio/actions/article_rag.py,sha256=PiOFxI6VTmLXm3BK-01g_KH1mTE9uOtnA-CwUjt16AU,1456
-fabricatio/actions/output.py,sha256=K7xsBH8MjXRH6JOy3ZO94KCQzX2jNrwPPK_rRXVkS0E,1161
+fabricatio/actions/output.py,sha256=eHI4EH5n1nOt6MqQ00b7UWTjIqO8FerNakem_45d5qk,2315
 fabricatio/actions/rag.py,sha256=QBdzEM8MloM_ahx5pTBZAETm9_631lTe_0ih_he_Iuo,2759
-fabricatio/capabilities/correct.py,sha256=8GOU2VBPUakjG-r59SqsCgCD0QHX-l__IynCLO-ib8Q,6482
+fabricatio/capabilities/correct.py,sha256=2093ggHkY8vQW8fl7VwXC8u39oW1xsfjxDjGoQ5puOA,7269
 fabricatio/capabilities/propose.py,sha256=y3kge5g6bb8HYuV8e9h4MdqOMTlsfAIZpqE_cagWPTY,1593
 fabricatio/capabilities/rag.py,sha256=XVvfH6rcog-moj1WCgwtR-l0-NdbFR6-fMQFLG7_asY,17690
 fabricatio/capabilities/rating.py,sha256=yEPqL5_DqVMj_AH9cMvKsHdMnSbvm8dN6PaKHLsJUPQ,14904
@@ -18,19 +18,19 @@ fabricatio/fs/curd.py,sha256=N6l2MncjrFfnXBRtteRouXp5Rjy8EAKC_i29_G-zz98,4618
 fabricatio/fs/readers.py,sha256=EZKN_AZdrp8DggJECP53QHw3uHeSDf-AwCAA_V7fNKU,1202
 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/action.py,sha256=FcgZPneEFQTgK2eEvafo2FvnGnqM5G8HytPddqHrq8A,8880
 fabricatio/models/events.py,sha256=QvlnS8FEELg6KNabcJMeh2GV_y0ZBzKOPphcteKYWYU,4183
-fabricatio/models/extra/article_base.py,sha256=Y4ZdC1yabs7jCNKwc-P8GpAJShGJx7EcLyhXuJ194Fo,11469
+fabricatio/models/extra/article_base.py,sha256=SwFiSyGHU7n5cD1B3eN2UjrZjW_pXgYI4zelxsdcTCI,15270
 fabricatio/models/extra/article_essence.py,sha256=DUESuK4CGgkRvIMoJCv4l8MNp5MawRYoNOtLCrFRPXY,9229
-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=yEpP4cvvmB0sDbs36pIl2KYFsnNRKq7V0m3HqoSQc7o,19492
+fabricatio/models/extra/article_main.py,sha256=S-Bu91KYQB7Ep5yMTUBmpI54RFjq_emM8MoIFyVEROQ,7721
+fabricatio/models/extra/article_outline.py,sha256=pIsO5bOSV-SUeWWdhkfkVpcr9RPOHgYmsceHsrXs67M,1145
+fabricatio/models/extra/article_proposal.py,sha256=DWn3MQUNQlXj9Fcm3xSONyxARz8goAroJUA6pWvBhHw,1398
+fabricatio/models/generic.py,sha256=nyfhgaIEsSvbDvcHrjULEgseBKRzZx2t21lfncwCsq4,19225
 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
 fabricatio/models/tool.py,sha256=kD0eB7OxO9geZOxO6JIKvCBeG-KOpRAkfRZqK_WGfW4,7105
-fabricatio/models/usages.py,sha256=BSqTENSva8Flga3bPBfwuc1nHo5Z_29oYzar99NbjLM,31566
+fabricatio/models/usages.py,sha256=BZXHdm198wMOaYvCqL7wBcSzAHUMS4mYeD_VCi08mmY,31736
 fabricatio/models/utils.py,sha256=yjxPZ6N7QGpGwkI_Vb28Ud3EhkdlB-tyfGRHAZMcGxs,5872
 fabricatio/parser.py,sha256=9Jzw-yV6uKbFvf6sPna-XHdziVGVBZWvPctgX_6ODL8,6251
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -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=db4DHfetEQMNh7hqmL6All-asJooQxFIIXZkoWKAx4c,1835008
-fabricatio-0.2.7.dev5.data/scripts/tdown.exe,sha256=xZcDsLIn9rJZcM8iDNgS-eNK4ckH5rufC6mU6I2vmOo,3399680
-fabricatio-0.2.7.dev5.dist-info/RECORD,,
+fabricatio/_rust.cp312-win_amd64.pyd,sha256=1wV10H3_yuAX2eZTIXTI1mhpTASH3dN491GXUBLKtDE,1830912
+fabricatio-0.2.8.dev0.data/scripts/tdown.exe,sha256=fEInXr-uYE9QwK0N2CINOHDjc22Odu_DY9Dk2JPDIg8,3399680
+fabricatio-0.2.8.dev0.dist-info/RECORD,,