fabricatio 0.2.13.dev3__cp312-cp312-win_amd64.whl → 0.3.14__cp312-cp312-win_amd64.whl

fabricatio/models/action.py

@@ -12,12 +12,11 @@ Classes:
 import traceback
 from abc import abstractmethod
 from asyncio import Queue, create_task
-from typing import Any, ClassVar, Dict, Self, Sequence, Tuple, Type, Union, final
+from typing import Any, ClassVar, Dict, Generator, 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 ToolBoxUsage
 from fabricatio.utils import override_kwargs
 from pydantic import Field, PrivateAttr
 
@@ -99,24 +98,21 @@ class Action(WithBriefing):
             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, task_output_key: str = OUTPUT_KEY) -> Self:
+    def to_task_output(self, to: Union[str, "WorkFlow"] = OUTPUT_KEY) -> Self:
         """Set the output key to OUTPUT_KEY and return the action instance."""
-        self.output_key = task_output_key
+        self.output_key = to.task_output_key if isinstance(to, WorkFlow) else to
         return self
 
 
-class WorkFlow(WithBriefing, ToolBoxUsage):
+class WorkFlow(WithBriefing):
     """Manages sequences of actions to fulfill tasks.
 
     Handles context propagation between actions, error handling, and task lifecycle
     events like cancellation and completion.
-
-    Attributes:
-        steps (Tuple): Sequence of Action instances or classes to execute.
-        task_input_key (str): Key for storing task instance in context.
-        task_output_key (str): Key to retrieve final result from context.
     """
 
+    name: str = "WorkFlow"
+    """The name of the workflow, which is used to identify and describe the workflow."""
     description: str = ""
     """The description of the workflow, which describes the workflow's purpose and requirements."""
 
@@ -129,10 +125,10 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     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)
+    task_input_key: ClassVar[str] = INPUT_KEY
     """Key used to store the input task in the context dictionary."""
 
-    task_output_key: str = Field(default=OUTPUT_KEY)
+    task_output_key: ClassVar[str] = OUTPUT_KEY
     """Key used to extract the final result from the context dictionary."""
 
     extra_init_context: Dict[str, Any] = Field(default_factory=dict, frozen=True)
@@ -143,10 +139,16 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
 
         Args:
             __context: The context to be used for initialization.
+
         """
+        self.name = self.name or self.__class__.__name__
         # Convert any action classes to instances
         self._instances = tuple(step if isinstance(step, Action) else step() for step in self.steps)
 
+    def iter_actions(self) -> Generator[Action, None, None]:
+        """Iterate over action instances."""
+        yield from self._instances
+
     def inject_personality(self, personality: str) -> Self:
         """Set personality for actions without existing personality.
 
@@ -248,24 +250,6 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
 
         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.
-
-        Returns:
-            Self: The workflow instance for method chaining.
-        """
-        self.hold_to(self._instances)
-        return self
-
-    def steps_supply_tools_from_self(self) -> Self:
-        """Provide this workflow's tools to all steps in the workflow.
-
-        Returns:
-            Self: The workflow instance for method chaining.
-        """
-        self.provide_tools_to(i for i in self._instances if isinstance(i, ToolBoxUsage))
-        return self
-
     def update_init_context(self, /, **kwargs) -> Self:
         """Update the initial context with additional key-value pairs.
 

fabricatio/models/extra/aricle_rag.py

@@ -1,6 +1,7 @@
 """A Module containing the article rag models."""
 
 import re
+from dataclasses import dataclass, field
 from itertools import groupby
 from pathlib import Path
 from typing import ClassVar, Dict, List, Optional, Self, Unpack
@@ -55,6 +56,7 @@ class ArticleChunk(MilvusDataBase):
 
     @property
     def reference_header(self) -> str:
+        """Get the reference header."""
         return f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}` from {self.as_auther_seq()}"
 
     @property
@@ -67,7 +69,7 @@ class ArticleChunk(MilvusDataBase):
 
     @classmethod
     def from_file[P: str | Path](
-        cls, path: P | List[P], bib_mgr: BibManager, **kwargs: Unpack[ChunkKwargs]
+            cls, path: P | List[P], bib_mgr: BibManager, **kwargs: Unpack[ChunkKwargs]
     ) -> List[Self]:
         """Load the article chunks from the file."""
         if isinstance(path, list):
@@ -84,9 +86,9 @@ class ArticleChunk(MilvusDataBase):
         title_seg = path.stem.split(" - ").pop()
 
         key = (
-            bib_mgr.get_cite_key_by_title(title_seg)
-            or bib_mgr.get_cite_key_by_title_fuzzy(title_seg)
-            or bib_mgr.get_cite_key_fuzzy(path.stem)
+                bib_mgr.get_cite_key_by_title(title_seg)
+                or bib_mgr.get_cite_key_by_title_fuzzy(title_seg)
+                or bib_mgr.get_cite_key_fuzzy(path.stem)
         )
         if key is None:
             logger.warning(f"no cite key found for {path.as_posix()}, skip.")
@@ -164,10 +166,11 @@ class ArticleChunk(MilvusDataBase):
         return self
 
 
+@dataclass
 class CitationManager(AsPrompt):
     """Citation manager."""
 
-    article_chunks: List[ArticleChunk] = Field(default_factory=list)
+    article_chunks: List[ArticleChunk] = field(default_factory=list)
     """Article chunks."""
 
     pat: str = r"(\[\[([\d\s,-]*)]])"
@@ -178,7 +181,7 @@ class CitationManager(AsPrompt):
     """Separator for abbreviated citation numbers."""
 
     def update_chunks(
-        self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True
+            self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True
     ) -> Self:
         """Update article chunks."""
         self.article_chunks.clear()
@@ -217,8 +220,9 @@ class CitationManager(AsPrompt):
     def _as_prompt_inner(self) -> Dict[str, str]:
         """Generate prompt inner representation."""
         seg = []
-        for k, g in groupby(self.article_chunks, key=lambda a: a.bibtex_cite_key):
-            g = list(g)
+        for k, g_iter in groupby(self.article_chunks, key=lambda a: a.bibtex_cite_key):
+            g = list(g_iter)
+
             logger.debug(f"Group [{k}]: {len(g)}")
             seg.append(wrapp_in_block("\n\n".join(a.chunk for a in g), first(g).reference_header))
         return {"References": "\n".join(seg)}
@@ -276,5 +280,7 @@ class CitationManager(AsPrompt):
         return "".join(a.as_typst_cite() for a in chunk_seq.values())
 
     def as_milvus_filter_expr(self, blacklist: bool = True) -> str:
+        """Asynchronously fetches documents from a Milvus database based on input vectors."""
         if blacklist:
             return " and ".join(f'bibtex_cite_key != "{a.bibtex_cite_key}"' for a in self.article_chunks)
+        return " or ".join(f'bibtex_cite_key == "{a.bibtex_cite_key}"' for a in self.article_chunks)

fabricatio/models/extra/article_base.py

@@ -5,6 +5,7 @@ from enum import StrEnum
 from pathlib import Path
 from typing import ClassVar, Generator, List, Optional, Self, Tuple, Type
 
+from fabricatio.capabilities.persist import PersistentAble
 from fabricatio.fs import dump_text, safe_text_read
 from fabricatio.fs.readers import extract_sections
 from fabricatio.journal import logger
@@ -15,14 +16,20 @@ from fabricatio.models.generic import (
     Introspect,
     Language,
     ModelHash,
-    PersistentAble,
     ProposedUpdateAble,
-    ResolveUpdateConflict,
     SketchedAble,
     Titled,
     WordCount,
 )
-from fabricatio.rust import extract_body, inplace_update, split_out_metadata, to_metadata, word_count
+from fabricatio.rust import (
+    comment,
+    extract_body,
+    replace_thesis_body,
+    split_out_metadata,
+    strip_comment,
+    to_metadata,
+    word_count,
+)
 from fabricatio.utils import fallback_kwargs, ok
 from pydantic import Field
 
@@ -53,10 +60,17 @@ class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
     aims: List[str]
     """List of writing aims of the research component in academic style."""
 
+    unstructured_body: str = ""
+    """Store the source of the unknown information."""
+
     @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))
+        data = self.model_dump(
+            include={"description", "aims", "expected_word_count"},
+            by_alias=True,
+        )
+        return to_metadata({k: v for k, v in data.items() if v})
 
 
 class FromTypstCode(ArticleMetaData):
@@ -69,12 +83,7 @@ class FromTypstCode(ArticleMetaData):
 
         return cls(
             heading=title,
-            **fallback_kwargs(
-                data or {},
-                elaboration="",
-                expected_word_count=word_count(body),
-                aims=[],
-            ),
+            **fallback_kwargs(data or {}, elaboration="", expected_word_count=word_count(body), aims=[]),
             **kwargs,
         )
 
@@ -84,11 +93,10 @@ class ToTypstCode(ArticleMetaData):
 
     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"
+        return f"{self.title}\n{self.typst_metadata_comment}\n\n{self.unstructured_body}"
 
 
 class ArticleOutlineBase(
-    ResolveUpdateConflict,
     ProposedUpdateAble,
     PersistentAble,
     ModelHash,
@@ -153,12 +161,12 @@ class SectionBase[T: SubSectionBase](ArticleOutlineBase):
     @classmethod
     def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Creates an Article object from the given Typst code."""
+        raw_subsec = extract_sections(body, level=3, section_char="=")
         return super().from_typst_code(
             title,
             body,
-            subsections=[
-                cls.child_type.from_typst_code(*pack) for pack in extract_sections(body, level=3, section_char="=")
-            ],
+            subsections=[cls.child_type.from_typst_code(*pack) for pack in raw_subsec],
+            unstructured_body="" if raw_subsec else strip_comment(body),
         )
 
     def resolve_update_conflict(self, other: Self) -> str:
@@ -193,6 +201,11 @@ class SectionBase[T: SubSectionBase](ArticleOutlineBase):
             return f"Section `{self.title}` contains no subsections, expected at least one, but got 0, you can add one or more as needed."
         return ""
 
+    @property
+    def exact_word_count(self) -> int:
+        """Returns the exact word count of the article section outline."""
+        return sum(a.exact_word_count for a in self.subsections)
+
 
 class ChapterBase[T: SectionBase](ArticleOutlineBase):
     """Base class for article chapters."""
@@ -208,12 +221,12 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
     @classmethod
     def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Creates an Article object from the given Typst code."""
+        raw_sec = extract_sections(body, level=2, section_char="=")
         return super().from_typst_code(
             title,
             body,
-            sections=[
-                cls.child_type.from_typst_code(*pack) for pack in extract_sections(body, level=2, section_char="=")
-            ],
+            sections=[cls.child_type.from_typst_code(*pack) for pack in raw_sec],
+            unstructured_body="" if raw_sec else strip_comment(body),
         )
 
     def resolve_update_conflict(self, other: Self) -> str:
@@ -245,6 +258,15 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
             return f"Chapter `{self.title}` contains no sections, expected at least one, but got 0, you can add one or more as needed."
         return ""
 
+    @property
+    def exact_word_count(self) -> int:
+        """Calculates the total word count across all sections in the chapter.
+
+        Returns:
+            int: The cumulative word count of all sections.
+        """
+        return sum(a.exact_word_count for a in self.sections)
+
 
 class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, ToTypstCode, ABC):
     """Base class for article outlines."""
@@ -265,15 +287,24 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, To
 
     child_type: ClassVar[Type[ChapterBase]]
 
+    @property
+    def exact_word_count(self) -> int:
+        """Calculates the total word count across all chapters in the article.
+
+        Returns:
+            int: The cumulative word count of all chapters.
+        """
+        return sum(ch.exact_word_count for ch in self.chapters)
+
     @classmethod
     def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Generates an article from the given Typst code."""
+        raw_chap = extract_sections(body, level=1, section_char="=")
         return super().from_typst_code(
             title,
             body,
-            chapters=[
-                cls.child_type.from_typst_code(*pack) for pack in extract_sections(body, level=1, section_char="=")
-            ],
+            chapters=[cls.child_type.from_typst_code(*pack) for pack in raw_chap],
+            unstructured_body="" if raw_chap else strip_comment(body),
         )
 
     def iter_dfs_rev(
@@ -352,7 +383,7 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, To
 
     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)
+        return comment(f"#Title: {super().to_typst_code()}\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.
@@ -403,11 +434,11 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, To
         """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()
 
-    def update_article_file(self, file: str | Path) -> Self:
+    def update_article_file[S: "ArticleBase"](self: S, file: str | Path) -> S:
         """Update the article file."""
         file = Path(file)
         string = safe_text_read(file)
-        if updated := inplace_update(string, ARTICLE_WRAPPER, self.to_typst_code()):
+        if updated := replace_thesis_body(string, ARTICLE_WRAPPER, f"\n\n{self.to_typst_code()}\n\n"):
             dump_text(file, updated)
             logger.success(f"Successfully updated {file.as_posix()}.")
         else:
@@ -415,7 +446,7 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, To
         return self
 
     @classmethod
-    def from_article_file(cls, file: str | Path, title: str) -> Self:
+    def from_article_file[S: "ArticleBase"](cls: Type[S], file: str | Path, title: str) -> S:
         """Load article from file."""
         file = Path(file)
         string = safe_text_read(file)

fabricatio/models/extra/article_essence.py

@@ -2,8 +2,9 @@
 
 from typing import List
 
+from fabricatio.capabilities.persist import PersistentAble
 from fabricatio.models.extra.rag import MilvusDataBase
-from fabricatio.models.generic import PersistentAble, SketchedAble
+from fabricatio.models.generic import SketchedAble
 from pydantic import BaseModel
 
 

fabricatio/models/extra/article_main.py

@@ -2,6 +2,7 @@
 
 from typing import ClassVar, Dict, Generator, List, Self, Tuple, Type, override
 
+from fabricatio.capabilities.persist import PersistentAble
 from fabricatio.decorators import precheck_package
 from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
@@ -16,17 +17,16 @@ from fabricatio.models.extra.article_outline import (
     ArticleSectionOutline,
     ArticleSubsectionOutline,
 )
-from fabricatio.models.generic import Described, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
+from fabricatio.models.generic import Described, SequencePatch, SketchedAble, WithRef, WordCount
 from fabricatio.rust import (
-    convert_all_block_tex,
-    convert_all_inline_tex,
+    convert_all_tex_math,
     fix_misplaced_labels,
     split_out_metadata,
     word_count,
 )
 from pydantic import Field, NonNegativeInt
 
-PARAGRAPH_SEP = "\n\n// - - -\n\n"
+PARAGRAPH_SEP = "// - - -"
 
 
 class Paragraph(SketchedAble, WordCount, Described):
@@ -49,10 +49,10 @@ class Paragraph(SketchedAble, WordCount, Described):
     @classmethod
     def from_content(cls, content: str) -> Self:
         """Create a Paragraph object from the given content."""
-        return cls(elaboration="", aims=[], expected_word_count=word_count(content), content=content)
+        return cls(elaboration="", aims=[], expected_word_count=word_count(content), content=content.strip())
 
     @property
-    def exact_wordcount(self) -> int:
+    def exact_word_count(self) -> int:
         """Calculates the exact word count of the content."""
         return word_count(self.content)
 
@@ -70,6 +70,11 @@ class ArticleSubsection(SubSectionBase):
     _max_word_count_deviation: float = 0.3
     """Maximum allowed deviation from the expected word count, as a percentage."""
 
+    @property
+    def exact_word_count(self) -> int:
+        """Calculates the exact word count of all paragraphs in the subsection."""
+        return sum(a.exact_word_count for a in self.paragraphs)
+
     @property
     def word_count(self) -> int:
         """Calculates the total word count of all paragraphs in the subsection."""
@@ -102,7 +107,7 @@ class ArticleSubsection(SubSectionBase):
         Returns:
             str: Typst code snippet for rendering.
         """
-        return super().to_typst_code() + PARAGRAPH_SEP.join(p.content for p in self.paragraphs)
+        return super().to_typst_code() + f"\n\n{PARAGRAPH_SEP}\n\n".join(p.content for p in self.paragraphs)
 
     @classmethod
     def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
@@ -154,15 +159,13 @@ class Article(
         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)
+                a.description = convert_all_tex_math(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)
+                    p.content = convert_all_tex_math(p.content)
         return self
 
     @override
@@ -275,9 +278,9 @@ class Article(
         err = []
         for chap, sec, subsec in self.iter_subsections():
             for i, p in enumerate(subsec.paragraphs):
-                if p.exact_wordcount <= threshold:
+                if p.exact_word_count <= threshold:
                     err.append(
-                        f"{chap.title}->{sec.title}->{subsec.title}-> Paragraph [{i}] is too short, {p.exact_wordcount} words."
+                        f"{chap.title}->{sec.title}->{subsec.title}-> Paragraph [{i}] is too short, {p.exact_word_count} words."
                     )
 
         return "\n".join(err)

fabricatio/models/extra/article_outline.py

@@ -2,6 +2,7 @@
 
 from typing import ClassVar, Dict, Type
 
+from fabricatio.capabilities.persist import PersistentAble
 from fabricatio.models.extra.article_base import (
     ArticleBase,
     ChapterBase,
@@ -9,7 +10,7 @@ from fabricatio.models.extra.article_base import (
     SubSectionBase,
 )
 from fabricatio.models.extra.article_proposal import ArticleProposal
-from fabricatio.models.generic import PersistentAble, WithRef
+from fabricatio.models.generic import WithRef
 
 
 class ArticleSubsectionOutline(SubSectionBase):

fabricatio/models/extra/article_proposal.py

@@ -2,11 +2,11 @@
 
 from typing import Dict, List
 
+from fabricatio.capabilities.persist import PersistentAble
 from fabricatio.models.generic import (
     AsPrompt,
     Described,
     Language,
-    PersistentAble,
     SketchedAble,
     Titled,
     WithRef,

fabricatio/models/extra/rag.py

@@ -5,7 +5,7 @@ from functools import partial
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Self, Sequence, Set
 
 from fabricatio.decorators import precheck_package
-from fabricatio.models.generic import Vectorizable
+from fabricatio.models.generic import Base, Vectorizable
 from fabricatio.utils import ok
 from pydantic import JsonValue
 
@@ -18,7 +18,7 @@ if TYPE_CHECKING:
         from pymilvus import CollectionSchema
 
 
-class MilvusDataBase(Vectorizable, ABC):
+class MilvusDataBase(Base, Vectorizable, ABC):
     """A base class for Milvus data."""
 
     primary_field_name: ClassVar[str] = "id"

fabricatio/models/extra/rule.py

@@ -10,7 +10,8 @@ complex rule management systems.
 
 from typing import List, Self, Tuple, Unpack
 
-from fabricatio.models.generic import Language, PersistentAble, SketchedAble, WithBriefing
+from fabricatio.capabilities.persist import PersistentAble
+from fabricatio.models.generic import Language, SketchedAble, WithBriefing
 from more_itertools import flatten