fabricatio 0.2.7.dev5__tar.gz → 0.2.8.dev1__tar.gz

{fabricatio-0.2.7.dev5 → fabricatio-0.2.8.dev1}/PKG-INFO

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

{fabricatio-0.2.7.dev5/examples/write_outline → fabricatio-0.2.8.dev1/examples/write_article}/.gitignore

@@ -1,2 +1,3 @@
 article_briefing.txt
-out.typ
+out.typ
+persistent

{fabricatio-0.2.7.dev5 → fabricatio-0.2.8.dev1}/examples/write_article/write_article.py

@@ -9,7 +9,7 @@ from fabricatio.actions.article import (
     GenerateArticleProposal,
     GenerateOutline,
 )
-from fabricatio.actions.output import DumpFinalizedOutput
+from fabricatio.actions.output import DumpFinalizedOutput, PersistentAll
 from fabricatio.models.task import Task
 
 
@@ -20,9 +20,7 @@ async def main() -> None:
         description="Write an outline for an article in typst format.",
         llm_top_p=0.8,
         llm_temperature=1.15,
-        llm_max_tokens=8192,
-        llm_model="openai/qwen-max",
-        llm_stream=True,
+        llm_model="litellm_proxy/qwen-max",
         registry={
             Event.quick_instantiate(ns := "article"): WorkFlow(
                 name="Generate Article Outline",
@@ -32,8 +30,13 @@ async def main() -> None:
                     GenerateOutline(llm_temperature=1.21, llm_top_p=0.3),
                     GenerateArticle(output_key="to_dump", llm_temperature=1.2, llm_top_p=0.45),
                     DumpFinalizedOutput(output_key="task_output"),
+                    PersistentAll,
                 ),
-            ).update_init_context(article_briefing=Path("./article_briefing.txt").read_text(), dump_path="out.typ")
+            ).update_init_context(
+                article_briefing=Path("./article_briefing.txt").read_text(),
+                dump_path="out.typ",
+                persist_dir="persistent",
+            )
         },
     )
 

{fabricatio-0.2.7.dev5 → fabricatio-0.2.8.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.7-dev5"
+version = "0.2.8-dev1"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

fabricatio-0.2.8.dev1/python/fabricatio/actions/article.py

@@ -0,0 +1,333 @@
+"""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
+from fabricatio.models.extra.article_proposal import ArticleProposal
+from fabricatio.models.task import Task
+from fabricatio.models.utils import ok
+
+
+class ExtractArticleEssence(Action):
+    """Extract the essence of article(s) in text format from the paths specified in the task dependencies.
+
+    Notes:
+        This action is designed to extract vital information from articles with Markdown format, which is pure text, and
+        which is converted from pdf files using `magic-pdf` from the `MinerU` project, see https://github.com/opendatalab/MinerU
+    """
+
+    output_key: str = "article_essence"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        task_input: Task,
+        reader: Callable[[str], str] = lambda p: Path(p).read_text(encoding="utf-8"),
+        **_,
+    ) -> Optional[List[ArticleEssence]]:
+        if not task_input.dependencies:
+            logger.info(err := "Task not approved, since no dependencies are provided.")
+            raise RuntimeError(err)
+
+        # 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}",
+        )
+
+
+class GenerateArticleProposal(Action):
+    """Generate an outline for the article based on the extracted essence."""
+
+    output_key: str = "article_proposal"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        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(
+            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.",
+                        )
+                    )
+                ),
+                **self.prepend_sys_msg(),
+            ),
+            "Could not generate the proposal.",
+        ).update_ref(briefing)
+        if langauge:
+            proposal.language = langauge
+
+        return proposal
+
+
+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(
+        self,
+        article_proposal: ArticleProposal,
+        **_,
+    ) -> Optional[ArticleOutline]:
+        return ok(
+            await self.propose(
+                ArticleOutline,
+                article_proposal.as_prompt(),
+                **self.prepend_sys_msg(),
+            ),
+            "Could not generate the initial outline.",
+        )
+
+
+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,
+        **_,
+    ) -> 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=False,
+                ),
+                "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,
+        **_,
+    ) -> 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."""
+
+    output_key: str = "article"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        article_outline: ArticleOutline,
+        **_,
+    ) -> Optional[Article]:
+        article: Article = Article.from_outline(ok(article_outline, "Article outline not specified.")).update_ref(
+            article_outline
+        )
+
+        write_para_manual = ok(
+            await self.draft_rating_manual(w_topic := "write the following paragraph in the subsection.")
+        )
+
+        await gather(
+            *[
+                self.correct_obj_inplace(
+                    subsec,
+                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
+                    topic=w_topic,
+                    rating_manual=write_para_manual,
+                    supervisor_check=False,
+                )
+                for _, __, subsec in article.iter_subsections()
+                if (err := subsec.introspect())
+            ],
+            return_exceptions=True,
+        )
+
+        return article
+
+
+class CorrectProposal(Action):
+    """Correct the proposal of the article."""
+
+    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-0.2.8.dev1/python/fabricatio/actions/output.py

@@ -0,0 +1,69 @@
+"""Dump the finalized output to a file."""
+
+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, PersistentAble
+from fabricatio.models.task import Task
+from fabricatio.models.utils import ok
+
+
+class DumpFinalizedOutput(Action):
+    """Dump the finalized output to a file."""
+
+    output_key: str = "dump_path"
+
+    async def _execute(
+        self,
+        to_dump: FinalizedDumpAble,
+        task_input: Optional[Task] = None,
+        dump_path: Optional[str | Path] = None,
+        **_,
+    ) -> str:
+        dump_path = Path(
+            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."
+                ),
+                "Could not find the path of file to dump the data.",
+            )
+        )
+        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-0.2.8.dev1/python/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-0.2.7.dev5 → fabricatio-0.2.8.dev1}/python/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-0.2.7.dev5 → fabricatio-0.2.8.dev1}/python/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-0.2.7.dev5 → fabricatio-0.2.8.dev1}/python/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-0.2.7.dev5 → fabricatio-0.2.8.dev1}/python/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-0.2.8.dev1/python/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