fabricatio 0.2.8.dev0__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.8.dev2__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/_rust.pyi

@@ -122,3 +122,53 @@ class BibManager:
         Returns:
             List of all titles in the bibliography
         """
+
+    def get_author_by_key(self, key: str) -> Optional[List[str]]:
+        """Retrieve authors by citation key.
+
+        Args:
+            key: Citation key
+
+        Returns:
+            List of authors if found, None otherwise
+        """
+
+    def get_year_by_key(self, key: str) -> Optional[int]:
+        """Retrieve the publication year by citation key.
+
+        Args:
+            key: Citation key
+
+        Returns:
+            Publication year if found, None otherwise
+        """
+
+    def get_abstract_by_key(self, key: str) -> Optional[str]:
+        """Retrieve the abstract by citation key.
+
+        Args:
+            key: Citation key
+
+        Returns:
+            Abstract if found, None otherwise
+        """
+    def get_title_by_key(self, key: str) -> Optional[str]:
+        """Retrieve the title by citation key.
+
+        Args:
+            key: Citation key
+
+        Returns:
+            Title if found, None otherwise
+        """
+
+    def get_field_by_key(self, key: str, field: str)-> Optional[str]:
+        """Retrieve a specific field by citation key.
+
+        Args:
+            key: Citation key
+            field: Field name
+
+        Returns:
+            Field value if found, None otherwise
+        """

fabricatio/actions/article.py

@@ -4,9 +4,12 @@ from asyncio import gather
 from pathlib import Path
 from typing import Any, Callable, List, Optional
 
+from fabricatio._rust import BibManager
+from fabricatio.capabilities.advanced_judge import AdvancedJudge
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
+from fabricatio.models.extra.article_base import ArticleRefPatch
 from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article
 from fabricatio.models.extra.article_outline import ArticleOutline
@@ -38,11 +41,27 @@ class ExtractArticleEssence(Action):
 
         # trim the references
         contents = ["References".join(c.split("References")[:-1]) for c in map(reader, task_input.dependencies)]
-        return await self.propose(
-            ArticleEssence,
-            contents,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-        )
+        return await self.propose(ArticleEssence, contents, **self.prepend_sys_msg())
+
+
+class FixArticleEssence(Action):
+    """Fix the article essence based on the bibtex key."""
+
+    async def _execute(
+        self,
+        bib_mgr: BibManager,
+        article_essence: List[ArticleEssence],
+        **_,
+    ) -> None:
+        for a in article_essence:
+            if key := (bib_mgr.get_cite_key(a.title) or bib_mgr.get_cite_key_fuzzy(a.title)):
+                a.title = bib_mgr.get_title_by_key(key) or a.title
+                a.authors = bib_mgr.get_author_by_key(key) or a.authors
+                a.publication_year = bib_mgr.get_year_by_key(key) or a.publication_year
+                a.bibtex_cite_key = key
+                logger.info(f'Updated {a.title} with {key}')
+            else:
+                logger.warning(f"No key found for {a.title}")
 
 
 class GenerateArticleProposal(Action):
@@ -88,10 +107,10 @@ class GenerateArticleProposal(Action):
         return proposal
 
 
-class GenerateOutline(Action):
-    """Generate the article based on the outline."""
+class GenerateInitialOutline(Action):
+    """Generate the initial article outline based on the article proposal."""
 
-    output_key: str = "article_outline"
+    output_key: str = "initial_article_outline"
     """The key of the output data."""
 
     async def _execute(
@@ -99,15 +118,28 @@ class GenerateOutline(Action):
         article_proposal: ArticleProposal,
         **_,
     ) -> Optional[ArticleOutline]:
-        out = ok(
+        return ok(
             await self.propose(
                 ArticleOutline,
                 article_proposal.as_prompt(),
                 **self.prepend_sys_msg(),
             ),
-            "Could not generate the outline.",
-        )
+            "Could not generate the initial outline.",
+        ).update_ref(article_proposal)
+
+
+class FixIntrospectedErrors(Action):
+    """Fix introspected errors in the article outline."""
+
+    output_key: str = "introspected_errors_fixed_outline"
+    """The key of the output data."""
 
+    async def _execute(
+        self,
+        article_outline: ArticleOutline,
+        supervisor_check: bool = False,
+        **_,
+    ) -> Optional[ArticleOutline]:
         introspect_manual = ok(
             await self.draft_rating_manual(
                 topic=(
@@ -118,21 +150,36 @@ class GenerateOutline(Action):
             "Could not generate the rating manual.",
         )
 
-        while pack := out.find_introspected():
+        while pack := article_outline.find_introspected():
             component, err = ok(pack)
             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}",
+                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
                     topic=intro_topic,
                     rating_manual=introspect_manual,
-                    supervisor_check=False,
+                    supervisor_check=supervisor_check,
                 ),
                 "Could not correct the component.",
             )
             component.update_from(corrected)
 
+        return article_outline
+
+
+class FixIllegalReferences(Action):
+    """Fix illegal references in the article outline."""
+
+    output_key: str = "illegal_references_fixed_outline"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        article_outline: ArticleOutline,
+        supervisor_check: bool = False,
+        **_,
+    ) -> Optional[ArticleOutline]:
         ref_manual = ok(
             await self.draft_rating_manual(
                 topic=(
@@ -143,19 +190,89 @@ class GenerateOutline(Action):
             "Could not generate the rating manual.",
         )
 
-        while pack := out.find_illegal_ref():
+        while pack := article_outline.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",
+                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
                     topic=ref_topic,
                     rating_manual=ref_manual,
-                    supervisor_check=False,
+                    supervisor_check=supervisor_check,
                 )
             )
-        return out.update_ref(article_proposal)
+        return article_outline.update_ref(article_outline)
+
+
+class TweakOutlineBackwardRef(Action, AdvancedJudge):
+    """Tweak the backward references in the article outline.
+
+    Ensures that the prerequisites of the current chapter are correctly referenced in the `depend_on` field.
+    """
+
+    output_key: str = "article_outline_bw_ref_checked"
+
+    async def _execute(self, article_outline: ArticleOutline, supervisor_check: bool = False, **cxt) -> ArticleOutline:
+        tweak_depend_on_manual = ok(
+            await self.draft_rating_manual(
+                topic := "Ensure prerequisites are correctly referenced in the `depend_on` field."
+            ),
+            "Could not generate the rating manual.",
+        )
+
+        for a in article_outline.iter_dfs():
+            if await self.evidently_judge(
+                f"{article_outline.as_prompt()}\n\n{a.display()}\n"
+                f"Does the `{a.__class__.__name__}`'s `depend_on` field need to be extended or tweaked?"
+            ):
+                patch = ArticleRefPatch.default()
+                patch.tweaked = a.depend_on
+
+                await self.correct_obj_inplace(
+                    patch,
+                    topic=topic,
+                    reference=f"{article_outline.as_prompt()}\nThe Article component whose `depend_on` field needs to be extended or tweaked",
+                    rating_manual=tweak_depend_on_manual,
+                    supervisor_check=supervisor_check,
+                )
+
+        return article_outline
+
+
+class TweakOutlineForwardRef(Action, AdvancedJudge):
+    """Tweak the forward references in the article outline.
+
+    Ensures that the conclusions of the current chapter effectively support the analysis of subsequent chapters.
+    """
+
+    output_key: str = "article_outline_fw_ref_checked"
+
+    async def _execute(self, article_outline: ArticleOutline, supervisor_check: bool = False, **cxt) -> ArticleOutline:
+        tweak_support_to_manual = ok(
+            await self.draft_rating_manual(
+                topic := "Ensure conclusions support the analysis of subsequent chapters, sections or subsections."
+            ),
+            "Could not generate the rating manual.",
+        )
+
+        for a in article_outline.iter_dfs():
+            if await self.evidently_judge(
+                f"{article_outline.as_prompt()}\n\n{a.display()}\n"
+                f"Does the `{a.__class__.__name__}`'s `support_to` field need to be extended or tweaked?"
+            ):
+                patch = ArticleRefPatch.default()
+                patch.tweaked = a.support_to
+
+                await self.correct_obj_inplace(
+                    patch,
+                    topic=topic,
+                    reference=f"{article_outline.as_prompt()}\nThe Article component whose `support_to` field needs to be extended or tweaked",
+                    rating_manual=tweak_support_to_manual,
+                    supervisor_check=supervisor_check,
+                )
+
+        return article_outline
 
 
 class GenerateArticle(Action):
@@ -167,6 +284,7 @@ class GenerateArticle(Action):
     async def _execute(
         self,
         article_outline: ArticleOutline,
+        supervisor_check: bool = False,
         **_,
     ) -> Optional[Article]:
         article: Article = Article.from_outline(ok(article_outline, "Article outline not specified.")).update_ref(
@@ -184,13 +302,14 @@ class GenerateArticle(Action):
                     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,
+                    supervisor_check=supervisor_check,
                 )
                 for _, __, subsec in article.iter_subsections()
                 if (err := subsec.introspect())
             ],
             return_exceptions=True,
         )
+
         return article
 
 

fabricatio/actions/article_rag.py

@@ -1,35 +1,90 @@
 """A module for writing articles using RAG (Retrieval-Augmented Generation) capabilities."""
 
-from typing import Optional
+from asyncio import gather
+from typing import Dict, Optional
 
 from fabricatio.capabilities.rag import RAG
-from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.extra.article_main import Article
-from fabricatio.models.extra.article_outline import ArticleOutline
+from fabricatio.models.extra.article_main import Article, ArticleParagraphPatch, ArticleSubsection
+from fabricatio.models.utils import ok
 
 
-class GenerateArticleRAG(Action, RAG):
+class TweakArticleRAG(Action, RAG):
     """Write an article based on the provided outline."""
 
-    output_key: str = "article"
+    output_key: str = "rag_tweaked_article"
 
-    async def _execute(self, article_outline: ArticleOutline, **cxt) -> Optional[Article]:
+    async def _execute(
+        self,
+        article: Article,
+        collection_name: str = "article_essence",
+        citation_requirement: str = "# Citation Format\n"
+        "Use correct citation format based on author count. Cite using author surnames and year:"
+        "For 3+ authors: 'Author1, Author2 et al. (YYYY)'"
+        "For 2 authors: 'Author1 & Author2 (YYYY)'"
+        "Single author: 'Author1 (YYYY)'"
+        "Multiple citations: 'Author1 (YYYY), Author2 (YYYY)'"
+        "Prioritize formulas from reference highlights."
+        "Specify authors/years only - no numeric citations"
+        "Paragraphs must exceed 2-3 sentences",
+        supervisor_check: bool = False,
+        parallel: bool = False,
+        **cxt,
+    ) -> Optional[Article]:
         """Write an article based on the provided outline."""
-        logger.info(f"Writing an article based on the outline:\n{article_outline.title}")
-        refined_q = await self.arefined_query(article_outline.display())
-        return await self.propose(
-            Article,
-            article_outline.display(),
-            **self.prepend_sys_msg(f"{await self.aretrieve_compact(refined_q)}\n{self.briefing}"),
+        criteria = await self.draft_rating_criteria(
+            topic := "choose appropriate reference to insert into the article, "
+            "making conclusions or reasoning based on concrete evidence instead of unreliable guesses."
+            "Extensively use formulas highlighted in reference文献 should be translated to 'references'."
+            "Only specify authors and years without numeric citation numbers (like [1],[2])."
+            "Each paragraph should not end with just 2-3 sentences for better readability.",
+            criteria_count=13,
         )
 
+        tweak_manual = ok(
+            await self.draft_rating_manual(topic, criteria=criteria, co_extractor={"model": "openai/qwen-max"})
+        )
+        self.view(collection_name)
 
-class WriteArticleFineGrind(Action, RAG):
-    """Fine-grind an article based on the provided outline."""
+        if parallel:
+            await gather(
+                *[
+                    self._inner(article, subsec, supervisor_check, citation_requirement, topic, tweak_manual)
+                    for _, __, subsec in article.iter_subsections()
+                ],
+                return_exceptions=True,
+            )
+        else:
+            for _, __, subsec in article.iter_subsections():
+                await self._inner(article, subsec, supervisor_check, citation_requirement, topic, tweak_manual)
 
-    output_key: str = "article"
+        return article
 
-    async def _execute(self, article_outline: ArticleOutline, **cxt) -> Optional[Article]:
-        """Fine-grind an article based on the provided outline."""
-        logger.info(f"Fine-grinding an article based on the outline:\n{article_outline.title}")
+    async def _inner(
+        self,
+        article: Article,
+        subsec: ArticleSubsection,
+        supervisor_check: bool,
+        citation_requirement: str,
+        topic: str,
+        tweak_manual: Dict[str, str],
+    ) -> None:
+        refind_q = ok(
+            await self.arefined_query(
+                f"{article.referenced.as_prompt()}\n"
+                f"# Subsection requiring reference enhancement\n"
+                f"{subsec.display()}\n"
+                f"# Requirement\n"
+                f"Search related articles in the base to find reference candidates, "
+                f"prioritizing both original article language and English usage",
+            )
+        )
+        patch = ArticleParagraphPatch.default()
+        patch.tweaked = subsec.paragraphs
+        await self.correct_obj_inplace(
+            patch,
+            reference=f"{await self.aretrieve_compact(refind_q, final_limit=50)}\n{citation_requirement}",
+            topic=topic,
+            rating_manual=tweak_manual,
+            supervisor_check=supervisor_check,
+        )

fabricatio/actions/output.py

@@ -1,7 +1,7 @@
 """Dump the finalized output to a file."""
 
 from pathlib import Path
-from typing import Optional
+from typing import Iterable, List, Optional, Type
 
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
@@ -14,6 +14,7 @@ class DumpFinalizedOutput(Action):
     """Dump the finalized output to a file."""
 
     output_key: str = "dump_path"
+    dump_path: Optional[str] = None
 
     async def _execute(
         self,
@@ -24,6 +25,7 @@ class DumpFinalizedOutput(Action):
     ) -> str:
         dump_path = Path(
             dump_path
+            or self.dump_path
             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 dump the data."
@@ -39,6 +41,7 @@ class PersistentAll(Action):
     """Persist all the data to a file."""
 
     output_key: str = "persistent_count"
+    persist_dir: Optional[str] = None
 
     async def _execute(
         self,
@@ -48,6 +51,7 @@ class PersistentAll(Action):
     ) -> int:
         persist_dir = Path(
             persist_dir
+            or self.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."
@@ -60,10 +64,38 @@ class PersistentAll(Action):
         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():
+
+        for k, v in cxt.items():
+            final_dir = persist_dir.joinpath(k)
+            final_dir.mkdir(parents=True, exist_ok=True)
             if isinstance(v, PersistentAble):
-                v.persist(persist_dir)
+                v.persist(final_dir)
                 count += 1
+            if isinstance(v, Iterable) and any(
+                persistent_ables := (pers for pers in v if isinstance(pers, PersistentAble))
+            ):
+                for per in persistent_ables:
+                    per.persist(final_dir)
+                    count += 1
 
         return count
+
+
+class RetrieveFromPersistent[T: PersistentAble](Action):
+    """Retrieve the object from the persistent file."""
+
+    output_key: str = "retrieved_obj"
+    """Retrieve the object from the persistent file."""
+    load_path: str
+    """The path of the persistent file or directory contains multiple file."""
+    retrieve_cls: Type[T]
+    """The class of the object to retrieve."""
+
+    async def _execute(self, /, **__) -> Optional[T | List[T]]:
+        logger.info(f"Retrieve `{self.retrieve_cls.__name__}` from persistent file: {self.load_path}")
+        if not (p := Path(self.load_path)).exists():
+            return None
+
+        if p.is_dir():
+            return [self.retrieve_cls.from_persistent(per) for per in p.glob("*")]
+        return self.retrieve_cls.from_persistent(self.load_path)

fabricatio/capabilities/advanced_judge.py

@@ -0,0 +1,23 @@
+"""The Capabilities module for advanced judging."""
+
+from typing import Optional, Unpack
+
+from fabricatio.capabilities.propose import Propose
+from fabricatio.models.extra.advanced_judge import JudgeMent
+from fabricatio.models.kwargs_types import ValidateKwargs
+
+
+class AdvancedJudge(Propose):
+    """A class that judges the evidence and makes a final decision."""
+    async def evidently_judge(
+        self,
+        prompt: str,
+        **kwargs: Unpack[ValidateKwargs[JudgeMent]],
+    ) -> Optional[JudgeMent]:
+        """Judge the evidence and make a final decision."""
+        return await self.propose(
+            JudgeMent,
+            prompt,
+            **kwargs
+        )
+

fabricatio/capabilities/rating.py

@@ -16,7 +16,7 @@ from more_itertools import flatten, windowed
 from pydantic import NonNegativeInt, PositiveInt
 
 
-class GiveRating(WithBriefing, LLMUsage):
+class Rating(WithBriefing, LLMUsage):
     """A class that provides functionality to rate tasks based on a rating manual and score range.
 
     References:

fabricatio/capabilities/review.py

@@ -4,7 +4,7 @@ from typing import Dict, List, Optional, Self, Set, Unpack, cast
 
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
-from fabricatio.capabilities.rating import GiveRating
+from fabricatio.capabilities.rating import Rating
 from fabricatio.config import configs
 from fabricatio.models.generic import Base, Display, ProposedAble, WithBriefing
 from fabricatio.models.kwargs_types import ReviewKwargs, ValidateKwargs
@@ -175,7 +175,7 @@ class ReviewResult[T](ProposedAble, Display):
         return self
 
 
-class Review(GiveRating, Propose):
+class Review(Rating, Propose):
     """Class that provides functionality to review tasks and strings using a language model.
 
     This class extends GiveRating and Propose capabilities to analyze content,

fabricatio/fs/curd.py

@@ -145,5 +145,9 @@ def gather_files(directory: str | Path | PathLike, extension: str) -> list[str]:
 
     Returns:
         list[str]: A list of file paths with the specified extension.
+
+    Example:
+        >>> gather_files('/path/to/directory', 'txt')
+        ['/path/to/directory/file1.txt', '/path/to/directory/file2.txt']
     """
     return [file.as_posix() for file in Path(directory).rglob(f"*.{extension}")]

fabricatio/models/action.py

@@ -104,7 +104,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
     """Instantiated action objects to be executed in this workflow."""
 
-    steps: Tuple[Union[Type[Action], Action], ...] = Field(...)
+    steps: Tuple[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="task_input")
@@ -157,13 +157,14 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
             # Process each action in sequence
             for step in self._instances:
                 current_action = step.name
-                logger.info(f"Executing step: {current_action}")
+                logger.info(f"Executing step >> {current_action}")
 
                 # Get current context and execute action
                 context = await self._context.get()
                 act_task = create_task(step.act(context))
                 # Handle task cancellation
                 if task.is_cancelled():
+                    logger.warning(f"Task cancelled by task: {task.name}")
                     act_task.cancel(f"Cancelled by task: {task.name}")
                     break
 
@@ -171,7 +172,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
                 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}")
+                    logger.success(f"Setting output to `{step.output_key}`")
                 await self._context.put(modified_ctx)
 
             logger.success(f"Workflow execution finished: {self.name}")
@@ -182,7 +183,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
 
             if self.task_output_key not in final_ctx:
                 logger.warning(
-                    f"Task output key: {self.task_output_key} not found in the context, None will be returned. "
+                    f"Task output key: `{self.task_output_key}` not found in the context, None will be returned. "
                     f"You can check if `Action.output_key` is set the same as `WorkFlow.task_output_key`."
                 )
 
@@ -221,7 +222,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         self.provide_tools_to(self._instances)
         return self
 
-    def update_init_context(self, **kwargs) -> Self:
+    def update_init_context(self, /, **kwargs) -> Self:
         """Update the initial context with additional key-value pairs.
 
         Args:

fabricatio/models/extra/advanced_judge.py

@@ -0,0 +1,29 @@
+"""Module containing the JudgeMent class for holding judgment results."""
+
+from typing import List
+
+from fabricatio.models.generic import ProposedAble
+
+
+class JudgeMent(ProposedAble):
+    """Represents a judgment result containing supporting/denying evidence and final verdict.
+
+    The class stores both affirmative and denies evidence lists along with the final boolean judgment.
+    """
+
+    affirm_evidence: List[str]
+    """List of evidence supporting the affirmation."""
+
+    deny_evidence: List[str]
+    """List of evidence supporting the denial."""
+
+    final_judgement: bool
+    """The final judgment made according to all extracted evidence."""
+
+    def __bool__(self) -> bool:
+        """Return the final judgment value.
+
+        Returns:
+            bool: The stored final_judgement value indicating the judgment result.
+        """
+        return self.final_judgement

fabricatio/models/extra/article_base.py

@@ -1,12 +1,13 @@
 """A foundation for hierarchical document components with dependency tracking."""
 
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from enum import StrEnum
 from functools import cache
 from itertools import chain
 from typing import Generator, List, Optional, Self, Tuple
 
 from fabricatio.models.generic import (
+    AsPrompt,
     CensoredAble,
     Display,
     FinalizedDumpAble,
@@ -121,6 +122,30 @@ class ArticleMetaData(CensoredAble, Display):
     """Do not add any prefix or suffix to the title. should not contain special characters."""
 
 
+class Patch[T](ProposedUpdateAble, Display):
+    """Base class for patches."""
+
+    tweaked: List[T]
+    """Tweaked content list"""
+    def update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        self.tweaked.clear()
+        self.tweaked.extend(other.tweaked)
+        return self
+
+
+    @classmethod
+    def default(cls) -> Self:
+        """Defaults to empty list."""
+        return cls(tweaked=[])
+
+
+class ArticleRefPatch(Patch[ArticleRef]):
+    """Patch for article refs."""
+
+
+
+
 class ArticleOutlineBase(
     ArticleMetaData,
     ResolveUpdateConflict,
@@ -267,7 +292,7 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
         return ""
 
 
-class ArticleBase[T: ChapterBase](FinalizedDumpAble):
+class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, ABC):
     """Base class for article outlines."""
 
     language: str

fabricatio/models/extra/article_essence.py

@@ -1,8 +1,8 @@
 """ArticleEssence: Semantic fingerprint of academic paper for structured analysis."""
 
-from typing import List
+from typing import List, Self
 
-from fabricatio.models.generic import Display, PrepareVectorization, ProposedAble
+from fabricatio.models.generic import Display, PersistentAble, PrepareVectorization, ProposedAble
 from pydantic import BaseModel, Field
 
 
@@ -20,12 +20,49 @@ class Equation(BaseModel):
     Example: "Defines constrained search space dimensionality reduction. Used in architecture optimization phase (Section 3.2). Enables 40% parameter reduction."
     """
 
-    latex_code: str
-    """LaTeX representation following academic typesetting standards:
-    - Must use equation environment (e.g., `equation`, `align`).
-    - Multiline equations must align at '=' using `&`.
-    - Include unit annotations where applicable.
-    Example: "\\begin{equation} \\mathcal{L}_{NAS} = \\alpha \\|\\theta\\|_2 + \\beta H(p) \\end{equation}"
+    typst_code: str
+    r"""The typst code for the equation, including the equation itself and any necessary formatting.
+#let x = 5  // Define a code variable
+
+// Basic syntax examples
+$x^2$  // Inline formula
+$ x^2 $  // Block formula (spaces before/after $ for standalone display)
+
+// Variables and text handling
+$ A = pi r^2 $  // Single-letter variables as-is
+$"area" = pi dot "radius"^2 $  // Multi-letter variables in quotes
+$ cal(A) := { x in RR | x "is natural" } $  // Calligraphic font and text
+$ #x < 17 $  // Access code variables with #
+
+// Symbols and shorthands
+$x < y => x gt.eq.not y $  // Symbol shorthand (=> for ⇒, gt.eq.not for ≯)
+
+// Multi-line equations with alignment
+$ sum_(k=0)^n k
+    &= 1 + ... + n \
+    &= (n(n+1))/2 $  // Multi-line with & alignment
+
+// Function calls and formatting
+$ frac(a^2, 2) $  // Fraction
+$ vec(1, 2, delim: "[") $  // Custom vector delimiter
+$ mat(1, 2; 3, 4) $  // 2D matrix (semicolon separates rows)
+$ mat(..#range(1, 5).chunks(2)) $  // Dynamic matrix with array expansion
+
+// Advanced alignment example
+$ (3x + y)/7 &= 9 && "given" \
+  3x + y    &= 63 & "multiply by 7" \
+  3x        &= 63 - y && "subtract y" \
+  x         &= 21 - y/3 & "divide by 3" $
+// && skips a column alignment (left/right alternation)
+
+// Math font configuration
+#show math.equation: set text(font: "Fira Math")  // Set math font (requires Fira Math installed)
+$ sum_(i in NN) 1 + i $  // Display with new font
+
+// Escaping and special syntax
+$ frac(a\,, b) $  // Escape comma to display as literal
+$ f(x; y) $  // Literal semicolon (not for 2D arrays)
+$ lim_x = op("lim", limits: #true)_x $  // Custom operator with limits
     """
 
 
@@ -133,11 +170,11 @@ class Highlightings(BaseModel):
     """
 
 
-class ArticleEssence(ProposedAble, Display, PrepareVectorization):
-    """Semantic fingerprint of academic paper for structured analysis.
+class ArticleEssence(ProposedAble, Display, PersistentAble, PrepareVectorization):
+    """ArticleEssence is a structured representation of the core elements of a scientific article,using its original language."""
 
-    Encodes research artifacts with dual human-machine interpretability.
-    """
+    language: str
+    """Language of the original article, note that you should not attempt to translate the original language when generating JSON."""
 
     title: str = Field(...)
     """Exact title of the original article without any modification.
@@ -149,7 +186,7 @@ class ArticleEssence(ProposedAble, Display, PrepareVectorization):
     """
 
     authors: List[str]
-    """Original author names exactly as they appear in the source document. No translation or paraphrasing.
+    """Original author full names exactly as they appear in the source document. No translation or paraphrasing.
     Extract complete list without any modifications or formatting changes."""
 
     keywords: List[str]
@@ -170,11 +207,7 @@ class ArticleEssence(ProposedAble, Display, PrepareVectorization):
     """Domain tags for research focus."""
 
     abstract: str = Field(...)
-    """Three-paragraph structured abstract:
-    Paragraph 1: Problem & Motivation (2-3 sentences)
-    Paragraph 2: Methodology & Innovations (3-4 sentences)
-    Paragraph 3: Results & Impact (2-3 sentences)
-    Total length: 150-250 words"""
+    """Abstract text with original language."""
 
     core_contributions: List[str]
     """3-5 technical contributions using CRediT taxonomy verbs.
@@ -184,6 +217,7 @@ class ArticleEssence(ProposedAble, Display, PrepareVectorization):
     - 'Established cross-lingual transfer metrics'"""
 
     technical_novelty: List[str]
+
     """Patent-style claims with technical specificity.
     Format: 'A [system/method] comprising [novel components]...'
     Example:
@@ -222,5 +256,13 @@ class ArticleEssence(ProposedAble, Display, PrepareVectorization):
     Example:
     'Predicted 150+ citations via integration into MMEngine (Alibaba OpenMMLab)'"""
 
+    bibtex_cite_key: str
+    """Bibtex cite_key of the original article."""
+
+    def update_cite_key(self, new_cite_key: str) -> Self:
+        """Update the bibtex_cite_key of the article."""
+        self.bibtex_cite_key = new_cite_key
+        return self
+
     def _prepare_vectorization_inner(self) -> str:
         return self.model_dump_json()

fabricatio/models/extra/article_main.py

@@ -1,13 +1,14 @@
 """ArticleBase and ArticleSubsection classes for managing hierarchical document components."""
 
 from itertools import chain
-from typing import Generator, List, Self, Tuple, override
+from typing import Dict, Generator, List, Self, Tuple, override
 
 from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
     ArticleBase,
     ArticleOutlineBase,
     ChapterBase,
+    Patch,
     SectionBase,
     SubSectionBase,
 )
@@ -31,6 +32,10 @@ class Paragraph(CensoredAble):
     """The actual content of the paragraph, represented as a string."""
 
 
+class ArticleParagraphPatch(Patch[Paragraph]):
+    """Patch for `Paragraph` list of `ArticleSubsection`."""
+
+
 class ArticleSubsection(SubSectionBase):
     """Atomic argumentative unit with technical specificity."""
 
@@ -81,6 +86,14 @@ class Article(
     aiming to provide a comprehensive model for academic papers.
     """
 
+    def _as_prompt_inner(self) -> Dict[str, str]:
+        return {
+            "Original Article Briefing": self.referenced.referenced.referenced,
+            "Original Article Proposal": self.referenced.referenced.display(),
+            "Original Article Outline": self.referenced.display(),
+            "Original Article": self.display(),
+        }
+
     @override
     def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
         return super().iter_subsections()

fabricatio/models/extra/article_outline.py

@@ -1,5 +1,7 @@
 """A module containing the ArticleOutline class, which represents the outline of an academic paper."""
 
+from typing import Dict
+
 from fabricatio.models.extra.article_base import (
     ArticleBase,
     ChapterBase,
@@ -30,3 +32,10 @@ class ArticleOutline(
     ArticleBase[ArticleChapterOutline],
 ):
     """Outline of an academic paper, containing chapters, sections, subsections."""
+
+    def _as_prompt_inner(self) -> Dict[str, str]:
+        return {
+            "Original Article Briefing": self.referenced.referenced,
+            "Original Article Proposal": self.referenced.display(),
+            "Original Article Outline": self.display(),
+        }

fabricatio/models/extra/article_proposal.py

@@ -29,5 +29,23 @@ class ArticleProposal(CensoredAble, Display, WithRef[str], AsPrompt, PersistentA
     research_aim: List[str]
     """A list of primary research objectives that the paper seeks to achieve."""
 
+    literature_review: List[str]
+    """A list of key references and literature that support the research context and background."""
+
+    expected_outcomes: List[str]
+    """A list of anticipated results or contributions that the research aims to achieve."""
+
+    keywords: List[str]
+    """A list of keywords that represent the main topics and focus areas of the research."""
+
+    abstract: str
+    """A concise summary of the research proposal, outlining the main points and objectives."""
+
+    min_word_count: int
+    """The minimum number of words required for the research proposal."""
+
     def _as_prompt_inner(self) -> Dict[str, str]:
-        return {"ArticleBriefing": self.referenced, "ArticleProposal": self.display()}
+        return {
+            "ArticleBriefing": self.referenced,
+            "ArticleProposal": self.display(),
+        }

fabricatio/models/generic.py

@@ -1,6 +1,7 @@
 """This module defines generic classes for models in the Fabricatio library."""
 
 from abc import ABC, abstractmethod
+from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Union, final, overload
 
@@ -93,7 +94,9 @@ class WithRef[T](Base):
     @property
     def referenced(self) -> T:
         """Get the referenced object."""
-        return ok(self._reference, "_reference is None")
+        return ok(
+            self._reference, f"`{self.__class__.__name__}`' s `_reference` field is None. Have you called `update_ref`?"
+        )
 
     def update_ref[S: "WithRef"](self: S, reference: T | S) -> S:  # noqa: PYI019
         """Update the reference of the object."""
@@ -118,17 +121,27 @@ class PersistentAble(Base):
         """
         p = Path(path)
         out = self.model_dump_json(indent=1)
+
+        # Generate a timestamp in the format YYYYMMDD_HHMMSS
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+        # Generate the hash
+        file_hash = blake3_hash(out.encode())[:6]
+
+        # Construct the file name with timestamp and hash
+        file_name = f"{self.__class__.__name__}_{timestamp}_{file_hash}.json"
+
         if p.is_dir():
-            p.joinpath(f"{self.__class__.__name__}_{blake3_hash(out.encode())[:6]}.json").write_text(
-                out, encoding="utf-8"
-            )
-            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()}")
+            p.joinpath(file_name).write_text(out, encoding="utf-8")
+        else:
+            p.mkdir(exist_ok=True, parents=True)
+            p.write_text(out, encoding="utf-8")
+
+        logger.info(f"Persisted `{self.__class__.__name__}` to {p.as_posix()}")
         return self
 
-    def from_persistent(self, path: str | Path) -> Self:
+    @classmethod
+    def from_persistent(cls, path: str | Path) -> Self:
         """Load the object from a file.
 
         Args:
@@ -137,7 +150,7 @@ class PersistentAble(Base):
         Returns:
             Self: The current instance of the object.
         """
-        return self.model_validate_json(Path(path).read_text(encoding="utf-8"))
+        return cls.model_validate_json(Path(path).read_text(encoding="utf-8"))
 
 
 class ModelHash(Base):
@@ -308,7 +321,7 @@ class ProposedAble(CreateJsonObjPrompt, InstantiateFromString):
     """Class that provides a method to propose a JSON object based on the requirement."""
 
 
-class ProposedUpdateAble(PersistentAble, UpdateFrom, ABC):
+class ProposedUpdateAble(ProposedAble, UpdateFrom, ABC):
     """Make the obj can be updated from the proposed obj in place."""
 
 

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

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

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

@@ -1,47 +1,49 @@
-fabricatio-0.2.8.dev0.dist-info/METADATA,sha256=jgTrZJZiqFyLRjwYSr96zd6uT0LKFrsao5BS5GTw49Q,5122
-fabricatio-0.2.8.dev0.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
-fabricatio-0.2.8.dev0.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
+fabricatio-0.2.8.dev2.dist-info/METADATA,sha256=WNFO2KnmBYDfJUfDNuvTaEpTEqeX02MNbmWA4FP7Zco,5122
+fabricatio-0.2.8.dev2.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
+fabricatio-0.2.8.dev2.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
 fabricatio/decorators.py,sha256=GrkclNTGT2bk7cjTyuca7mqSVlKwTcujcj3uBuZpT8s,7343
 fabricatio/core.py,sha256=MaEKZ6DDmbdScAY-7F1gwGA6fr7ADX6Mz5rNVi2msFA,6277
-fabricatio/models/generic.py,sha256=gbm1BnJqhdw42rx2Dcq1f13EnLVUKqFOJB_LxQhQg3M,18664
+fabricatio/models/generic.py,sha256=lGwngVLqhUYDdNub0V-JgAd6ePBaBF-7Vg5who72VBc,19074
 fabricatio/models/tool.py,sha256=ifivEnYiEUtjeRxQkX8vjfyzn1m1acgfrsABbQqCsGs,6912
 fabricatio/models/role.py,sha256=UgIfGdfIBu4cOug8Nm1a04JCEwjXR_MDZUQhumwMptk,2710
 fabricatio/models/kwargs_types.py,sha256=2tiApAy8JvpkDWKk_26_X1_g08mcHHKQz3c8pCd73x0,5286
 fabricatio/models/utils.py,sha256=MYwUmvr2P2F4Q3b73IUft2D8WG5FN3hMHLBXKtru0kU,5678
-fabricatio/models/extra/article_proposal.py,sha256=UGH55J6T4oR6tPiOxP4nmUIXavBHUOURKlibT2PiQn0,1365
-fabricatio/models/extra/article_main.py,sha256=ssh8FWo5HzOdm77LArsQzv61yg3CBKMSxtctjYbmxM4,7519
-fabricatio/models/extra/article_essence.py,sha256=q80VKO11QONkounDL98IpfG6DSC8ymfm7iQiWkzp3rY,9003
-fabricatio/models/extra/article_outline.py,sha256=aiqPCB4j-m3dl5n3R7gn_Idqx5kST1hbnGZhondz2DA,1113
-fabricatio/models/extra/article_base.py,sha256=hekBRwPGg1fyGwCqW2n-EU1OjVc3QXsWElaBymo7F_k,14888
+fabricatio/models/extra/article_proposal.py,sha256=hPkc2bfalTwdDiCpwpQ0KVbBWINBFOrsY0-WaufohCU,1992
+fabricatio/models/extra/advanced_judge.py,sha256=N0nyzIj-Zz3Edxmt79wgdd05nk9ddnVFPvNXmPGUTR8,881
+fabricatio/models/extra/article_main.py,sha256=TEElG2eRnY6NCb02O7BHUISxPfmB3KT4HRQCKzB5OoA,7998
+fabricatio/models/extra/article_essence.py,sha256=sKXn_Itm03ikEMQZqB8w0bgX8pl6n66qWTvL5Q9jk1g,10538
+fabricatio/models/extra/article_outline.py,sha256=EMKo4CBxU3ns6UhM1eDtoo-14MjEKT7cFs_CqrXbEhU,1409
+fabricatio/models/extra/article_base.py,sha256=M3icbgJ64NlqR6au6-UK9GQejz7XzE3Z1YP_8nP6VDY,15484
 fabricatio/models/usages.py,sha256=1TJ-wzMtPKIH1hYhWliv-IfjxUVvbJIdj5BO0_4nRy0,31003
 fabricatio/models/events.py,sha256=UvOc6V3vfjKuvh7irDezJ8EGpsNo5yzLdq4xQexVonw,4063
 fabricatio/models/task.py,sha256=-EnzpEyM6Z687gF1lPcmA2szEUw6dFpu3lOtseaz95o,10193
-fabricatio/models/action.py,sha256=yEYayK_gNtggpVgWlQ4K4wCHPqlhkouhUKW1SsJoR20,8646
+fabricatio/models/action.py,sha256=1tZZOcUghcmCf-YRHZLztGXHo3pHg6bKoQcBrNrvDSA,8741
 fabricatio/toolboxes/fs.py,sha256=OQMdeokYxSNVrCZJAweJ0cYiK4k2QuEiNdIbS5IHIV8,705
 fabricatio/toolboxes/__init__.py,sha256=dYm_Gd8XolSU_h4wnkA09dlaLDK146eeFz0CUgPZ8_c,380
 fabricatio/toolboxes/arithmetic.py,sha256=sSTPkKI6-mb278DwQKFO9jKyzc9kCx45xNH7V6bGBpE,1307
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fabricatio/fs/readers.py,sha256=5bLlpqcdhIwWfysh7gvfVv0PPPVAeDlTPGwNTio6j9M,1156
-fabricatio/fs/curd.py,sha256=FuG75qco4dX8vhIK27gKz9rKUXbWHOFg5yK3nGLB25s,4469
+fabricatio/fs/curd.py,sha256=QqwnyLdVALNnerYGXf6a0irqoPSNE9_GJV9bJ33kbl0,4610
 fabricatio/fs/__init__.py,sha256=hTuYtzmvIGtbg7PTdoqLEQJ0E63hOzZltCIrLlDKaSE,559
 fabricatio/config.py,sha256=o_lbhLJgkdxIkonLsAw2-zc2pntTui1CZmSvXMGASpc,16507
 fabricatio/journal.py,sha256=Op0wC-JlZumnAc_aDmYM4ljnSNLoKEEMfcIRbCF69ow,455
 fabricatio/__init__.py,sha256=6EjK4SxbnvFxdO9ftkXD9rxSuoPEIITNzUkuMO9s3yU,1092
-fabricatio/actions/output.py,sha256=22IwSPukxFT_Yf0rdEBuUFKTfUipOLx_ZieW0PHAlkI,2246
-fabricatio/actions/article_rag.py,sha256=jAoFU75vZ-jFROGh4bZKmvY10K9zJPLqzeEa7wSiwu8,1421
+fabricatio/actions/output.py,sha256=wq3qZeWfiP804EWdBbJxKvuUjZ2anHA5u_Ydv8iw4dY,3528
+fabricatio/actions/article_rag.py,sha256=NfyMsRYNgXMV0DepaiKbEiSdCA5uDwzld3yZxtBh2pw,3705
 fabricatio/actions/rag.py,sha256=Tsjn9IkO8OlKlhBBnk7J6qh9st61jzD6SUYClGhYs7I,2686
-fabricatio/actions/article.py,sha256=Oi67XUw_lE4Fdb6RzrgdbEdFBG4WutPRQQWBk5HbOms,8077
+fabricatio/actions/article.py,sha256=0suvbfYnmEblkbzmHNAuvZ8i_D7mJlJVcij5aaM2150,12830
 fabricatio/_rust_instances.py,sha256=bQmlhUCcxTmRgvw1SfzYzNNpgW_UCjmkYw5f-VPAyg8,304
 fabricatio/workflows/articles.py,sha256=oHNV5kNKEcOKP55FA7I1SlxQRlk6N26cpem_QYu05g0,1021
 fabricatio/workflows/rag.py,sha256=uOZXprD479fUhLA6sYvEM8RWcVcUZXXtP0xRbTMPdHE,509
 fabricatio/parser.py,sha256=OV6bIAfLJ-GfaKoTeIOqS3X3GqCgyvzSJsgYMO3ogj4,6100
+fabricatio/capabilities/advanced_judge.py,sha256=bvb8fYoiKoGlBwMZVMflVE9R2MoS1VtmZAo65jMJFew,683
 fabricatio/capabilities/correct.py,sha256=t9H-5FmbK78ahh0LhS4FAuOTw5qTkgkwIuBolkzYeBI,7104
 fabricatio/capabilities/rag.py,sha256=FsjaMKeFgl-kBmUGDfkWn2Sa9Gp1AfOWpOZRZXZlNFY,17270
-fabricatio/capabilities/rating.py,sha256=K6dIaMDMWNUhCenuP_lFriaofj6gBPjfNXEILp5yzjU,14556
-fabricatio/capabilities/review.py,sha256=_m7uGNfhW7iDhcCJrLiSBmEvMq56fpPIzNGh1X20YZM,11103
+fabricatio/capabilities/rating.py,sha256=eH9nxA2LnrXJSlZurP6PJzoIIIuj0vymIOVOPMxdDYA,14552
+fabricatio/capabilities/review.py,sha256=shXINMqiWbwROCQjBp3LVTvfKBhUkeq6LTpNhgy1z6Y,11095
 fabricatio/capabilities/propose.py,sha256=4QvONVVUp1rs34Te2Rjams6NioEt6FhEAxDWiveQnSg,1544
 fabricatio/capabilities/task.py,sha256=5XUxYNkPIHKm-Q0_oCeEqS-i3kfq9twHqcDiZL0rKVo,4526
-fabricatio/_rust.pyi,sha256=n6mFYqLQlyfumJZQ_E3SesR_yLrjfRLjf6N1VdlF6U8,3707
-fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=wQr2FLieZwAKIXasejND5CX7Y4-vhRHwqI8ds00bK9Y,1916040
-fabricatio-0.2.8.dev0.data/scripts/tdown,sha256=zC3ne1G7HqaXSJ2QJlv0ILXfKgT758L15JvGfbiC1gE,4588888
-fabricatio-0.2.8.dev0.dist-info/RECORD,,
+fabricatio/_rust.pyi,sha256=EAFwyMO99EnW2bZvZPWLRYsJpWYEZSuex86IhfANWHY,4929
+fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=ls1CFomHDbJJPgKtybXyG40iXkuv6-HisOksMjm9A70,1962488
+fabricatio-0.2.8.dev2.data/scripts/tdown,sha256=fRnbNXbWK0TZwVR5bNvDSoijRc2r5ixc8iyU7e63D2A,4605176
+fabricatio-0.2.8.dev2.dist-info/RECORD,,