fabricatio 0.2.7.dev5__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.8.dev1__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/actions/article.py

@@ -1,11 +1,14 @@
 """Actions for transmitting tasks to targets."""
 
+from asyncio import gather
 from pathlib import Path
 from typing import Any, Callable, List, Optional
 
+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
@@ -55,13 +58,14 @@ class GenerateArticleProposal(Action):
         task_input: Optional[Task] = None,
         article_briefing: Optional[str] = None,
         article_briefing_path: Optional[str] = None,
+        langauge: Optional[str] = None,
         **_,
     ) -> Optional[ArticleProposal]:
         if article_briefing is None and article_briefing_path is None and task_input is None:
             logger.error("Task not approved, since all inputs are None.")
             return None
 
-        return ok(
+        proposal = ok(
             await self.propose(
                 ArticleProposal,
                 briefing := (
@@ -78,14 +82,18 @@ class GenerateArticleProposal(Action):
                 ),
                 **self.prepend_sys_msg(),
             ),
-            "Could not generate the proposal."
+            "Could not generate the proposal.",
         ).update_ref(briefing)
+        if langauge:
+            proposal.language = langauge
 
+        return proposal
 
-class GenerateOutline(Action):
-    """Generate the article based on the outline."""
 
-    output_key: str = "article_outline"
+class GenerateInitialOutline(Action):
+    """Generate the initial article outline based on the article proposal."""
+
+    output_key: str = "initial_article_outline"
     """The key of the output data."""
 
     async def _execute(
@@ -93,62 +101,158 @@ 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.",
         )
 
-        manual = ok(await self.draft_rating_manual(
-            topic=(
-                topic
-                := "Fix the internal referring error, make sure there is no more `ArticleRef` pointing to a non-existing article component."
-            ),
-        ),"Could not generate the rating manual.")
 
-        while pack := out.find_illegal():
-            component, err = ok(pack)
-            logger.warning(f"Found error in the outline: \n{err}")
-            corrected = ok(await self.correct_obj(
-                component,
-                reference=f"# Original Article Outline\n{out.display()}\n# Error Need to be fixed\n{err}",
-                topic=topic,
-                rating_manual=manual,
-                supervisor_check=False,
-            ),"Could not correct the component.")
-            component.update_from(corrected)
-        return out.update_ref(article_proposal)
+class FixIntrospectedErrors(Action):
+    """Fix introspected errors in the article outline."""
 
+    output_key: str = "introspected_errors_fixed_outline"
+    """The key of the output data."""
 
-class CorrectProposal(Action):
-    """Correct the proposal of the article."""
+    async def _execute(
+        self,
+        article_outline: ArticleOutline,
+        **_,
+    ) -> 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.",
+        )
 
-    output_key: str = "corrected_proposal"
+        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=False,
+                ),
+                "Could not correct the component.",
+            )
+            component.update_from(corrected)
 
-    async def _execute(self, article_proposal: ArticleProposal, **_) -> Any:
-        return (await self.censor_obj(article_proposal, reference=article_proposal.referenced)).update_ref(
-            article_proposal
-        )
+        return article_outline
 
 
-class CorrectOutline(Action):
-    """Correct the outline of the article."""
+class FixIllegalReferences(Action):
+    """Fix illegal references in the article outline."""
 
-    output_key: str = "corrected_outline"
+    output_key: str = "illegal_references_fixed_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
+    ) -> 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."
+                ),
+            ),
+            "Could not generate the rating manual.",
+        )
+
+        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{article_outline.display()}\n# Error Need to be fixed\n{err}\n\n",
+                    topic=ref_topic,
+                    rating_manual=ref_manual,
+                    supervisor_check=False,
+                )
+            )
+        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, **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,
+                )
+
+        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, **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,
+                )
+
+        return article_outline
+
 
 class GenerateArticle(Action):
     """Generate the article based on the outline."""
@@ -161,49 +265,59 @@ class GenerateArticle(Action):
         article_outline: ArticleOutline,
         **_,
     ) -> Optional[Article]:
-        article: Article = Article.from_outline(article_outline).update_ref(article_outline)
+        article: Article = Article.from_outline(ok(article_outline, "Article outline not specified.")).update_ref(
+            article_outline
+        )
 
-        writing_manual = ok(await self.draft_rating_manual(
-            topic=(
-                topic_1
-                := "improve the content of the subsection to fit the outline. SHALL never add or remove any section or subsection, you can only add or delete paragraphs within the subsection."
-            ),
-        ))
-        err_resolve_manual = ok(await self.draft_rating_manual(
-            topic=(topic_2 := "this article component has violated the constrain, please correct it.")
-        ))
-        for c, deps in article.iter_dfs_with_deps(chapter=False):
-            logger.info(f"Updating the article component: \n{c.display()}")
-
-            out = ok(
-                await self.correct_obj(
-                    c,
-                    reference=(
-                        ref := f"{article_outline.referenced.as_prompt()}\n" + "\n".join(d.display() for d in deps)
-                    ),
-                    topic=topic_1,
-                    rating_manual=writing_manual,
+        write_para_manual = ok(
+            await self.draft_rating_manual(w_topic := "write the following paragraph in the subsection.")
+        )
+
+        await gather(
+            *[
+                self.correct_obj_inplace(
+                    subsec,
+                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
+                    topic=w_topic,
+                    rating_manual=write_para_manual,
                     supervisor_check=False,
-                ),
-                "Could not correct the article component.",
-            )
-            while err := c.resolve_update_conflict(out):
-                logger.warning(f"Found error in the article component: \n{err}")
-                out = ok(
-                    await self.correct_obj(
-                        out,
-                        reference=f"{ref}\n\n# Violated Error\n{err}",
-                        topic=topic_2,
-                        rating_manual=err_resolve_manual,
-                        supervisor_check=False,
-                    ),
-                    "Could not correct the article component.",
                 )
+                for _, __, subsec in article.iter_subsections()
+                if (err := subsec.introspect())
+            ],
+            return_exceptions=True,
+        )
 
-            c.update_from(out)
         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."""
 

fabricatio/actions/output.py

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

fabricatio/capabilities/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/correct.py

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

fabricatio/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/models/action.py

@@ -170,6 +170,8 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
                 # Update context with modified values
                 modified_ctx = await act_task
                 logger.success(f"Step execution finished: {current_action}")
+                if step.output_key:
+                    logger.success(f"Setting output: {step.output_key}")
                 await self._context.put(modified_ctx)
 
             logger.success(f"Workflow execution finished: {self.name}")
@@ -219,7 +221,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,22 @@
+"""A module containing the JudgeMent class."""
+
+from typing import List
+
+from fabricatio.models.generic import ProposedAble
+
+
+class JudgeMent(ProposedAble):
+    """A class representing a judgment made by a judge."""
+
+    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 judgement."""
+
+    def __bool__(self) -> bool:
+        """Return the final judgement."""
+        return self.final_judgement