fabricatio 0.2.7.dev5__tar.gz → 0.2.8.dev0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.7.dev5
+Version: 0.2.8.dev0
 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.dev0/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.dev0}/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.dev0}/pyproject.toml

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

{fabricatio-0.2.7.dev5 → fabricatio-0.2.8.dev0}/python/fabricatio/actions/article.py

@@ -1,5 +1,6 @@
 """Actions for transmitting tasks to targets."""
 
+from asyncio import gather
 from pathlib import Path
 from typing import Any, Callable, List, Optional
 
@@ -55,13 +56,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,8 +80,12 @@ 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):
@@ -102,27 +108,92 @@ class GenerateOutline(Action):
             "Could not generate the 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."
+        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.")
+            "Could not generate the rating manual.",
+        )
 
-        while pack := out.find_illegal():
+        while pack := out.find_introspected():
             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.")
+            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}",
+                    topic=intro_topic,
+                    rating_manual=introspect_manual,
+                    supervisor_check=False,
+                ),
+                "Could not correct the component.",
+            )
             component.update_from(corrected)
+
+        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 := out.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",
+                    topic=ref_topic,
+                    rating_manual=ref_manual,
+                    supervisor_check=False,
+                )
+            )
         return out.update_ref(article_proposal)
 
 
+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."""
 
@@ -150,60 +221,6 @@ class CorrectOutline(Action):
         )
 
 
-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(article_outline).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,
-                    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.",
-                )
-
-            c.update_from(out)
-        return article
-
-
 class CorrectArticle(Action):
     """Correct the article based on the outline."""
 

fabricatio-0.2.8.dev0/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.7.dev5 → fabricatio-0.2.8.dev0}/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.dev0}/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}")