fabricatio 0.2.8.dev3__cp312-cp312-win_amd64.whl → 0.2.9__cp312-cp312-win_amd64.whl

fabricatio/__init__.py

@@ -1,10 +1,6 @@
 """Fabricatio is a Python library for building llm app using event-based agent structure."""
 
-from importlib.util import find_spec
-
-from fabricatio import actions, toolboxes, workflows
-from fabricatio._rust import BibManager
-from fabricatio._rust_instances import TEMPLATE_MANAGER
+from fabricatio import actions, capabilities, toolboxes, workflows
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models import extra
@@ -14,6 +10,8 @@ from fabricatio.models.role import Role
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
 from fabricatio.parser import Capture, GenericCapture, JsonCapture, PythonCapture
+from fabricatio.rust import BibManager
+from fabricatio.rust_instances import TEMPLATE_MANAGER
 
 __all__ = [
     "TEMPLATE_MANAGER",
@@ -29,15 +27,10 @@ __all__ = [
     "ToolBox",
     "WorkFlow",
     "actions",
+    "capabilities",
     "env",
     "extra",
     "logger",
     "toolboxes",
     "workflows",
 ]
-
-
-if find_spec("pymilvus"):
-    from fabricatio.capabilities.rag import RAG
-
-    __all__ += ["RAG"]

fabricatio/actions/__init__.py

@@ -0,0 +1 @@
+"""A module containing some builtin actins."""

fabricatio/actions/article.py

@@ -2,24 +2,27 @@
 
 from asyncio import gather
 from pathlib import Path
-from typing import Any, Callable, List, Optional
+from typing import Callable, List, Optional
 
-from fabricatio._rust import BibManager
-from fabricatio.capabilities.advanced_judge import AdvancedJudge
+from more_itertools import filter_map
+
+from fabricatio.capabilities.censor import Censor
+from fabricatio.capabilities.propose import Propose
 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_base import ArticleRef, SubSectionBase
 from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.article_proposal import ArticleProposal
+from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.task import Task
+from fabricatio.rust import BibManager, detect_language
 from fabricatio.utils import ok
-from more_itertools import filter_map
 
 
-class ExtractArticleEssence(Action):
+class ExtractArticleEssence(Action, Propose):
     """Extract the essence of article(s) in text format from the paths specified in the task dependencies.
 
     Notes:
@@ -47,11 +50,11 @@ class ExtractArticleEssence(Action):
         out = []
 
         for ess in await self.propose(
-                ArticleEssence,
-                [
-                    f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it."
-                    for c in contents
-                ],
+            ArticleEssence,
+            [
+                f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it.\n\nWrite the value string using `{detect_language(c)}`"
+                for c in contents
+            ],
         ):
             if ess is None:
                 logger.warning("Could not extract article essence")
@@ -91,7 +94,7 @@ class FixArticleEssence(Action):
         return out
 
 
-class GenerateArticleProposal(Action):
+class GenerateArticleProposal(Action, Propose):
     """Generate an outline for the article based on the extracted essence."""
 
     output_key: str = "article_proposal"
@@ -102,38 +105,33 @@ 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
 
-        proposal = ok(
+        briefing = article_briefing or safe_text_read(
+            ok(
+                article_briefing_path
+                or await self.awhich_pathstr(
+                    f"{ok(task_input).briefing}\nExtract the path of file which contains the article briefing."
+                ),
+                "Could not find the path of file to read.",
+            )
+        )
+
+        logger.info("Start generating the proposal.")
+        return ok(
             await self.propose(
                 ArticleProposal,
-                briefing := (
-                    article_briefing
-                    or safe_text_read(
-                        ok(
-                            article_briefing_path
-                            or await self.awhich_pathstr(
-                                f"{ok(task_input).briefing}\nExtract the path of file which contains the article briefing."
-                            ),
-                            "Could not find the path of file to read.",
-                        )
-                    )
-                ),
+                f"{briefing}\n\nWrite the value string using `{detect_language(briefing)}` as written language.",
             ),
             "Could not generate the proposal.",
         ).update_ref(briefing)
-        if langauge:
-            proposal.language = langauge
-
-        return proposal
 
 
-class GenerateInitialOutline(Action):
+class GenerateInitialOutline(Action, Propose):
     """Generate the initial article outline based on the article proposal."""
 
     output_key: str = "initial_article_outline"
@@ -144,135 +142,146 @@ class GenerateInitialOutline(Action):
         article_proposal: ArticleProposal,
         **_,
     ) -> Optional[ArticleOutline]:
+        raw_outline = await self.aask(
+            f"{(article_proposal.as_prompt())}\n\nNote that you should use `{article_proposal.language}` to write the `ArticleOutline`\n"
+            f"Design each chapter of a proper and academic and ready for release manner.\n"
+            f"You Must make sure every chapter have sections, and every section have subsections.\n"
+            f"Make the chapter and sections and subsections bing divided into a specific enough article component.",
+        )
+
         return ok(
             await self.propose(
                 ArticleOutline,
-                article_proposal.as_prompt(),
+                f'{raw_outline}\n\n\n\noutline provided above is the outline i need to extract to a JSON,'
             ),
             "Could not generate the initial outline.",
         ).update_ref(article_proposal)
 
 
-class FixIntrospectedErrors(Action):
+class FixIntrospectedErrors(Action, Censor):
     """Fix introspected errors in the article outline."""
 
     output_key: str = "introspected_errors_fixed_outline"
     """The key of the output data."""
 
+    ruleset: Optional[RuleSet] = None
+    """The ruleset to use to fix the introspected errors."""
+    max_error_count: Optional[int] = None
+    """The maximum number of errors to fix."""
+
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        supervisor_check: bool = False,
+        intro_fix_ruleset: Optional[RuleSet] = None,
         **_,
     ) -> Optional[ArticleOutline]:
-        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.",
-        )
-
-        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{article_outline.display()}\n# Error Need to be fixed\n{err}",
-                    topic=intro_topic,
-                    rating_manual=introspect_manual,
-                    supervisor_check=supervisor_check,
+        counter = 0
+        origin = article_outline
+        while pack := article_outline.gather_introspected():
+            logger.info(f"Found {counter}th introspected errors")
+            logger.warning(f"Found introspected error: {pack}")
+            article_outline = ok(
+                await self.censor_obj(
+                    article_outline,
+                    ruleset=ok(intro_fix_ruleset or self.ruleset, "No ruleset provided"),
+                    reference=f"{article_outline.display()}\n # Fatal Error of the Original Article Outline\n{pack}",
                 ),
                 "Could not correct the component.",
-            )
-            component.update_from(corrected)
+            ).update_ref(origin)
+
+            if self.max_error_count and counter > self.max_error_count:
+                logger.warning("Max error count reached, stopping.")
+                break
+            counter += 1
 
         return article_outline
 
 
-class FixIllegalReferences(Action):
+class FixIllegalReferences(Action, Censor):
     """Fix illegal references in the article outline."""
 
     output_key: str = "illegal_references_fixed_outline"
     """The key of the output data."""
 
+    ruleset: Optional[RuleSet] = None
+    """Ruleset to use to fix the illegal references."""
+    max_error_count: Optional[int] = None
+    """The maximum number of errors to fix."""
+
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        supervisor_check: bool = False,
+        ref_fix_ruleset: Optional[RuleSet] = None,
         **_,
     ) -> Optional[ArticleOutline]:
-        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."
+        counter = 0
+        while pack := article_outline.find_illegal_ref():
+            logger.info(f"Found {counter}th illegal references")
+            cmp, ref, err = ok(pack)
+            logger.warning(f"Found illegal referring error: {err}\n\n{cmp.display()}")
+            new = ok(
+                await self.censor_obj_inplace(
+                    cmp,
+                    ruleset=ok(ref_fix_ruleset or self.ruleset, "No ruleset provided"),
+                    reference=f"{article_outline.as_prompt()}\n# `ArticleRef` usage doc\n{ArticleRef.__doc__}\n# Invalid `ArticleRef`\n```json\n{ref}```\n\n# Some Ref errors found that need to be fixed for the `ArticleRef`\n{err}",
                 ),
-            ),
-            "Could not generate the rating manual.",
-        )
-
-        while pack := article_outline.find_illegal_ref(gather_identical=True):
-            refs, err = ok(pack)
-            logger.warning(f"Found illegal referring error: {err}")
-            corrected_ref = ok(
-                await self.correct_obj(
-                    refs[0],  # pyright: ignore [reportIndexIssue]
-                    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=supervisor_check,
-                )
+                "Could not correct the component",
             )
-            for ref in refs:
-                ref.update_from(corrected_ref)  # pyright: ignore [reportAttributeAccessIssue]
 
-        return article_outline.update_ref(article_outline)
+            logger.info(f"Applying correction:\n{new.display()}")
+            if self.max_error_count and counter > self.max_error_count:
+                logger.warning("Max error count reached, stopping.")
+                break
+            counter += 1
+
+        return article_outline
 
 
-class TweakOutlineForwardRef(Action, AdvancedJudge):
+class TweakOutlineForwardRef(Action, Censor):
     """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"
+    ruleset: Optional[RuleSet] = None
+    """Ruleset to use to fix the illegal references."""
 
-    async def _execute(self, article_outline: ArticleOutline, supervisor_check: bool = False, **cxt) -> ArticleOutline:
+    async def _execute(
+        self, article_outline: ArticleOutline, ref_twk_ruleset: Optional[RuleSet] = None, **cxt
+    ) -> ArticleOutline:
         return await self._inner(
             article_outline,
-            supervisor_check,
-            topic="Ensure conclusions support the analysis of subsequent chapters, sections or subsections.",
+            ruleset=ok(ref_twk_ruleset or self.ruleset, "No ruleset provided"),
             field_name="support_to",
         )
 
-    async def _inner(
-        self, article_outline: ArticleOutline, supervisor_check: bool, topic: str, field_name: str
-    ) -> ArticleOutline:
-        tweak_support_to_manual = ok(
-            await self.draft_rating_manual(topic),
-            "Could not generate the rating manual.",
+    async def _inner(self, article_outline: ArticleOutline, ruleset: RuleSet, field_name: str) -> ArticleOutline:
+        await gather(
+            *[self._loop(a[-1], article_outline, field_name, ruleset) for a in article_outline.iter_subsections()],
         )
-        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 `{field_name}` field need to be extended or tweaked?"
-            ):
-                patch = ArticleRefPatch.default()
-                patch.tweaked = getattr(a, field_name)
-
-                await self.correct_obj_inplace(
-                    patch,
-                    topic=topic,
-                    reference=f"{article_outline.as_prompt()}\nThe Article component whose `{field_name}` field needs to be extended or tweaked",
-                    rating_manual=tweak_support_to_manual,
-                    supervisor_check=supervisor_check,
-                )
+
         return article_outline
 
+    async def _loop(
+        self, a: SubSectionBase, article_outline: ArticleOutline, field_name: str, ruleset: RuleSet
+    ) -> None:
+        if judge := await self.evidently_judge(
+            f"{article_outline.as_prompt()}\n\n{a.display()}\n"
+            f"# `ArticleRef` usage doc\n{ArticleRef.__doc__}\n"
+            f"# Ruleset\n{ruleset.display()}\n"
+            f"Does the `{a.__class__.__name__}`'s `{field_name}` field contains inappropriate ref that obviously violated the ruleset provided?\n"
+            f"true for it does violated, false for it does not violated."
+        ):
+            await self.censor_obj_inplace(
+                a,
+                ruleset=ruleset,
+                reference=f"{article_outline.as_prompt()}\n"
+                f"The Article component titled `{a.title}` whose `{field_name}` field needs to be tweaked.\n"
+                f"# `ArticleRef` usage doc\n{ArticleRef.__doc__}\n"
+                f"# Judgement\n{judge.display()}",
+            )
+
 
 class TweakOutlineBackwardRef(TweakOutlineForwardRef):
     """Tweak the backward references in the article outline.
@@ -281,91 +290,45 @@ class TweakOutlineBackwardRef(TweakOutlineForwardRef):
     """
 
     output_key: str = "article_outline_bw_ref_checked"
+    ruleset: Optional[RuleSet] = None
 
-    async def _execute(self, article_outline: ArticleOutline, supervisor_check: bool = False, **cxt) -> ArticleOutline:
+    async def _execute(
+        self, article_outline: ArticleOutline, ref_twk_ruleset: Optional[RuleSet] = None, **cxt
+    ) -> ArticleOutline:
         return await self._inner(
             article_outline,
-            supervisor_check,
-            topic="Ensure the dependencies of the current chapter are neither abused nor missing.",
+            ruleset=ok(ref_twk_ruleset or self.ruleset, "No ruleset provided"),
             field_name="depend_on",
         )
 
 
-class GenerateArticle(Action):
+class GenerateArticle(Action, Censor):
     """Generate the article based on the outline."""
 
     output_key: str = "article"
     """The key of the output data."""
+    ruleset: Optional[RuleSet] = None
 
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        supervisor_check: bool = False,
+        article_gen_ruleset: Optional[RuleSet] = None,
         **_,
     ) -> 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(
+                self.censor_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=supervisor_check,
+                    ruleset=ok(article_gen_ruleset or self.ruleset, "No ruleset provided"),
+                    reference=f"{article_outline.as_prompt()}\n# `ArticleRef` usage doc\n{ArticleRef.__doc__}# Error Need to be fixed\n{err}\nYou should use `{subsec.language}` to write the new `Subsection`.",
                 )
-                for _, __, subsec in article.iter_subsections()
-                if (err := subsec.introspect())
+                for _, _, subsec in article.iter_subsections()
+                if (err := subsec.introspect()) and logger.warning(f"Found Introspection Error:\n{err}") is None
             ],
-            return_exceptions=True,
         )
 
         return article
-
-
-class CorrectProposal(Action):
-    """Correct the proposal of the article."""
-
-    output_key: str = "corrected_proposal"
-
-    async def _execute(self, article_proposal: ArticleProposal, **_) -> Any:
-        return (await self.censor_obj(article_proposal, reference=article_proposal.referenced)).update_ref(
-            article_proposal
-        )
-
-
-class CorrectOutline(Action):
-    """Correct the outline of the article."""
-
-    output_key: str = "corrected_outline"
-    """The key of the output data."""
-
-    async def _execute(
-        self,
-        article_outline: ArticleOutline,
-        **_,
-    ) -> ArticleOutline:
-        return (await self.censor_obj(article_outline, reference=article_outline.referenced.as_prompt())).update_ref(
-            article_outline
-        )
-
-
-class CorrectArticle(Action):
-    """Correct the article based on the outline."""
-
-    output_key: str = "corrected_article"
-    """The key of the output data."""
-
-    async def _execute(
-        self,
-        article: Article,
-        article_outline: ArticleOutline,
-        **_,
-    ) -> Article:
-        return await self.censor_obj(article, reference=article_outline.referenced.as_prompt())

fabricatio/actions/article_rag.py

@@ -1,73 +1,89 @@
 """A module for writing articles using RAG (Retrieval-Augmented Generation) capabilities."""
 
 from asyncio import gather
-from typing import Dict, Optional
+from typing import Optional
 
+from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.rag import RAG
 from fabricatio.models.action import Action
-from fabricatio.models.extra.article_main import Article, ArticleParagraphPatch, ArticleSubsection
+from fabricatio.models.extra.article_main import Article, ArticleSubsection
+from fabricatio.models.extra.rule import RuleSet
 from fabricatio.utils import ok
 
 
-class TweakArticleRAG(Action, RAG):
-    """Write an article based on the provided outline."""
+class TweakArticleRAG(Action, RAG, Censor):
+    """Write an article based on the provided outline.
+
+    This class inherits from `Action`, `RAG`, and `Censor` to provide capabilities for writing and refining articles
+    using Retrieval-Augmented Generation (RAG) techniques. It processes an article outline, enhances subsections by
+    searching for related references, and applies censoring rules to ensure compliance with the provided ruleset.
+
+    Attributes:
+        output_key (str): The key used to store the output of the action.
+        ruleset (Optional[RuleSet]): The ruleset to be used for censoring the article.
+    """
 
     output_key: str = "rag_tweaked_article"
+    """The key used to store the output of the action."""
+
+    ruleset: Optional[RuleSet] = None
+    """The ruleset to be used for censoring the article."""
+
+    ref_limit: int = 30
+    """The limit of references to be retrieved"""
 
     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."
-        "You can create numeric citation numbers for article whose `bibtex_cite_key` is 'wangWind2024' by using notation like `#cite(<wangWind2024>)`."
-        "Paragraphs must exceed 2-3 sentences",
-        supervisor_check: bool = False,
+        twk_rag_ruleset: Optional[RuleSet] = None,
         parallel: bool = False,
         **cxt,
     ) -> Optional[Article]:
-        """Write an article based on the provided outline."""
-        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,
-        )
+        """Write an article based on the provided outline.
+
+        This method processes the article outline, either in parallel or sequentially, by enhancing each subsection
+        with relevant references and applying censoring rules.
+
+        Args:
+            article (Article): The article to be processed.
+            collection_name (str): The name of the collection to view for processing.
+            twk_rag_ruleset (Optional[RuleSet]): The ruleset to apply for censoring. If not provided, the class's ruleset is used.
+            parallel (bool): If True, process subsections in parallel. Otherwise, process them sequentially.
+            **cxt: Additional context parameters.
 
-        tweak_manual = ok(await self.draft_rating_manual(topic, criteria=criteria))
+        Returns:
+            Optional[Article]: The processed article with enhanced subsections and applied censoring rules.
+        """
         self.view(collection_name)
 
         if parallel:
             await gather(
                 *[
-                    self._inner(article, subsec, supervisor_check, citation_requirement, topic, tweak_manual)
+                    self._inner(article, subsec, ok(twk_rag_ruleset or self.ruleset, "No ruleset provided!"))
                     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)
-
+                await self._inner(article, subsec, ok(twk_rag_ruleset or self.ruleset, "No ruleset provided!"))
         return article
 
-    async def _inner(
-        self,
-        article: Article,
-        subsec: ArticleSubsection,
-        supervisor_check: bool,
-        citation_requirement: str,
-        topic: str,
-        tweak_manual: Dict[str, str],
-    ) -> None:
+    async def _inner(self, article: Article, subsec: ArticleSubsection, ruleset: RuleSet) -> None:
+        """Enhance a subsection of the article with references and apply censoring rules.
+
+        This method refines the query for the subsection, retrieves related references, and applies censoring rules
+        to the subsection's paragraphs.
+
+        Args:
+            article (Article): The article containing the subsection.
+            subsec (ArticleSubsection): The subsection to be enhanced.
+            ruleset (RuleSet): The ruleset to apply for censoring.
+
+        Returns:
+            None
+        """
         refind_q = ok(
             await self.arefined_query(
                 f"{article.referenced.as_prompt()}\n"
@@ -75,15 +91,15 @@ class TweakArticleRAG(Action, RAG):
                 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",
+                f"provide queries in both `English` and `{subsec.language}` can get more accurate results.",
             )
         )
-        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,
+        await self.censor_obj_inplace(
+            subsec,
+            ruleset=ruleset,
+            reference=f"{await self.aretrieve_compact(refind_q, final_limit=self.ref_limit)}\n\n"
+            f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
+            f"You should Always use `{subsec.language}` as written language, "
+            f"which is the original language of the `{subsec.title}`. "
+            f"since rewrite a `{subsec.__class__.__name__}` in a different language is usually a bad choice",
         )