fabricatio 0.2.6.dev1__cp312-cp312-win_amd64.whl → 0.2.7.dev2__cp312-cp312-win_amd64.whl

fabricatio/__init__.py

@@ -2,59 +2,42 @@
 
 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.actions.article import ExtractArticleEssence, GenerateArticleProposal, GenerateOutline
-from fabricatio.actions.output import DumpFinalizedOutput
 from fabricatio.core import env
-from fabricatio.fs import MAGIKA, safe_json_read, safe_text_read
 from fabricatio.journal import logger
+from fabricatio.models import extra
 from fabricatio.models.action import Action, WorkFlow
 from fabricatio.models.events import Event
-from fabricatio.models.extra import ArticleEssence
 from fabricatio.models.role import Role
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
-from fabricatio.models.utils import Message, Messages
 from fabricatio.parser import Capture, GenericCapture, JsonCapture, PythonCapture
-from fabricatio.toolboxes import arithmetic_toolbox, basic_toolboxes, fs_toolbox
-from fabricatio.workflows.articles import WriteOutlineWorkFlow
 
 __all__ = [
-    "MAGIKA",
     "TEMPLATE_MANAGER",
     "Action",
-    "ArticleEssence",
     "BibManager",
     "Capture",
-    "DumpFinalizedOutput",
     "Event",
-    "ExtractArticleEssence",
-    "GenerateArticleProposal",
-    "GenerateOutline",
     "GenericCapture",
     "JsonCapture",
-    "Message",
-    "Messages",
     "PythonCapture",
     "Role",
     "Task",
     "ToolBox",
     "WorkFlow",
-    "WriteOutlineWorkFlow",
-    "arithmetic_toolbox",
-    "basic_toolboxes",
+    "actions",
     "env",
-    "fs_toolbox",
+    "extra",
     "logger",
-    "safe_json_read",
-    "safe_text_read",
+    "toolboxes",
+    "workflows",
 ]
 
 
 if find_spec("pymilvus"):
-    from fabricatio.actions.rag import InjectToDB
     from fabricatio.capabilities.rag import RAG
-    from fabricatio.workflows.rag import StoreArticle
 
-    __all__ += ["RAG", "InjectToDB", "StoreArticle"]
+    __all__ += ["RAG"]

fabricatio/_rust.pyi

@@ -9,6 +9,7 @@ class TemplateManager:
 
     See: https://crates.io/crates/handlebars
     """
+
     def __init__(
         self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
     ) -> None:
@@ -54,6 +55,17 @@ class TemplateManager:
             RuntimeError: If template rendering fails
         """
 
+    def render_template_raw(self, template: str, data: Dict[str, Any]) -> str:
+        """Render a template with context data.
+
+        Args:
+            template: The template string
+            data: Context dictionary to provide variables to the template
+
+        Returns:
+            Rendered template content as string
+        """
+
 def blake3_hash(content: bytes) -> str:
     """Calculate the BLAKE3 cryptographic hash of data.
 
@@ -100,3 +112,13 @@ class BibManager:
             Uses nucleo_matcher for high-quality fuzzy text searching
             See: https://crates.io/crates/nucleo-matcher
         """
+
+    def list_titles(self, is_verbatim: Optional[bool] = False) -> List[str]:
+        """List all titles in the bibliography.
+
+        Args:
+            is_verbatim: Whether to return verbatim titles (without formatting)
+
+        Returns:
+            List of all titles in the bibliography
+        """

fabricatio/actions/article.py

@@ -1,14 +1,14 @@
 """Actions for transmitting tasks to targets."""
 
-from os import PathLike
 from pathlib import Path
-from typing import Callable, List, Optional
+from typing import Any, Callable, List, Optional
 
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.extra import ArticleEssence, ArticleOutline, ArticleProposal
+from fabricatio.models.extra import Article, ArticleEssence, ArticleOutline, ArticleProposal
 from fabricatio.models.task import Task
+from fabricatio.models.utils import ok
 
 
 class ExtractArticleEssence(Action):
@@ -22,10 +22,10 @@ class ExtractArticleEssence(Action):
     output_key: str = "article_essence"
     """The key of the output data."""
 
-    async def _execute[P: PathLike | str](
+    async def _execute(
         self,
         task_input: Task,
-        reader: Callable[[P], str] = lambda p: Path(p).read_text(encoding="utf-8"),
+        reader: Callable[[str], str] = lambda p: Path(p).read_text(encoding="utf-8"),
         **_,
     ) -> Optional[List[ArticleEssence]]:
         if not task_input.dependencies:
@@ -49,24 +49,39 @@ class GenerateArticleProposal(Action):
 
     async def _execute(
         self,
-        task_input: Task,
+        task_input: Optional[Task] = None,
+        article_briefing: Optional[str] = None,
+        article_briefing_path: Optional[str] = None,
         **_,
     ) -> Optional[ArticleProposal]:
-        input_path = await self.awhich_pathstr(
-            f"{task_input.briefing}\nExtract the path of file, which contains the article briefing that I need to read."
-        )
-
-        return await self.propose(
-            ArticleProposal,
-            safe_text_read(input_path),
-            system_message=f"# your personal briefing: \n{self.briefing}",
-        )
+        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 (
+            await self.propose(
+                ArticleProposal,
+                briefing := (
+                    article_briefing
+                    or safe_text_read(
+                        ok(
+                            article_briefing_path
+                            or await self.awhich_pathstr(
+                                f"{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(),
+            )
+        ).update_ref(briefing)
 
 
 class GenerateOutline(Action):
     """Generate the article based on the outline."""
 
-    output_key: str = "article"
+    output_key: str = "article_outline"
     """The key of the output data."""
 
     async def _execute(
@@ -74,8 +89,121 @@ class GenerateOutline(Action):
         article_proposal: ArticleProposal,
         **_,
     ) -> Optional[ArticleOutline]:
-        return await self.propose(
+        out = await self.propose(
             ArticleOutline,
-            article_proposal.display(),
-            system_message=f"# your personal briefing: \n{self.briefing}",
+            article_proposal.as_prompt(),
+            **self.prepend_sys_msg(),
         )
+
+        manual = 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."
+            ),
+        )
+        while err := out.resolve_ref_error():
+            logger.warning(f"Found error in the outline: \n{err}")
+            out = await self.correct_obj(
+                out,
+                reference=f"# Referring Error\n{err}",
+                topic=topic,
+                rating_manual=manual,
+                supervisor_check=False,
+            )
+        return out.update_ref(article_proposal)
+
+
+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 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 = 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 = 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_error(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."""
+
+    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/output.py

@@ -1,8 +1,12 @@
 """Dump the finalized output to a file."""
 
+from pathlib import Path
+from typing import Optional
+
 from fabricatio.models.action import Action
 from fabricatio.models.generic import FinalizedDumpAble
 from fabricatio.models.task import Task
+from fabricatio.models.utils import ok
 
 
 class DumpFinalizedOutput(Action):
@@ -10,10 +14,21 @@ class DumpFinalizedOutput(Action):
 
     output_key: str = "dump_path"
 
-    async def _execute(self, task_input: Task, to_dump: FinalizedDumpAble, **_) -> str:
-        dump_path = await self.awhich_pathstr(
-            f"{task_input.briefing}\n\nExtract a single path of the file, to which I will dump the data."
+    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.",
+            )
         )
-
-        to_dump.finalized_dump_to(dump_path)
-        return dump_path
+        ok(to_dump, "Could not dump the data since the path is not specified.").finalized_dump_to(dump_path)
+        return dump_path.as_posix()

fabricatio/actions/rag.py

@@ -3,8 +3,11 @@
 from typing import List, Optional
 
 from fabricatio.capabilities.rag import RAG
+from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.generic import PrepareVectorization
+from fabricatio.models.task import Task
+from questionary import text
 
 
 class InjectToDB(Action, RAG):
@@ -13,13 +16,58 @@ class InjectToDB(Action, RAG):
     output_key: str = "collection_name"
 
     async def _execute[T: PrepareVectorization](
-        self, to_inject: T | List[T], collection_name: Optional[str] = "my_collection", **_
+        self, to_inject: Optional[T] | List[Optional[T]], collection_name: str = "my_collection",override_inject:bool=False, **_
     ) -> Optional[str]:
         if not isinstance(to_inject, list):
             to_inject = [to_inject]
-
+        logger.info(f"Injecting {len(to_inject)} items into the collection '{collection_name}'")
+        if override_inject:
+            self.check_client().client.drop_collection(collection_name)
         await self.view(collection_name, create=True).consume_string(
-            [t.prepare_vectorization(self.embedding_max_sequence_length) for t in to_inject],
+            [
+                t.prepare_vectorization(self.embedding_max_sequence_length)
+                for t in to_inject
+                if isinstance(t, PrepareVectorization)
+            ],
         )
 
         return collection_name
+
+
+class RAGTalk(Action, RAG):
+    """RAG-enabled conversational action that processes user questions based on a given task.
+
+    This action establishes an interactive conversation loop where it retrieves context-relevant
+    information to answer user queries according to the assigned task briefing.
+
+    Notes:
+        task_input: Task briefing that guides how to respond to user questions
+        collection_name: Name of the vector collection to use for retrieval (default: "my_collection")
+
+    Returns:
+        Number of conversation turns completed before termination
+    """
+
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **kwargs) -> int:
+        collection_name = kwargs.get("collection_name", "my_collection")
+        counter = 0
+
+        self.view(collection_name, create=True)
+
+        try:
+            while True:
+                user_say = await text("User: ").ask_async()
+                if user_say is None:
+                    break
+                gpt_say = await self.aask_retrieved(
+                    user_say,
+                    user_say,
+                    extra_system_message=f"You have to answer to user obeying task assigned to you:\n{task_input.briefing}",
+                )
+                print(f"GPT: {gpt_say}")  # noqa: T201
+                counter += 1
+        except KeyboardInterrupt:
+            logger.info(f"executed talk action {counter} times")
+        return counter

fabricatio/capabilities/correct.py

@@ -5,14 +5,16 @@ to provide mechanisms for reviewing, validating, and correcting various objects
 based on predefined criteria and templates.
 """
 
-from typing import Optional, Unpack
+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 Display, ProposedAble, WithBriefing
-from fabricatio.models.kwargs_types import ReviewKwargs
+from fabricatio.models.generic import CensoredAble, Display, ProposedAble, WithBriefing
+from fabricatio.models.kwargs_types import CensoredCorrectKwargs, CorrectKwargs, ReviewKwargs
 from fabricatio.models.task import Task
+from questionary import confirm, text
+from rich import print as rprint
 
 
 class Correct(Review):
@@ -25,7 +27,11 @@ class Correct(Review):
     """
 
     async def correct_obj[M: ProposedAble](
-        self, obj: M, **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]]
+        self,
+        obj: M,
+        reference: str = "",
+        supervisor_check: bool = True,
+        **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]],
     ) -> Optional[M]:
         """Review and correct an object based on defined criteria and templates.
 
@@ -34,6 +40,8 @@ class Correct(Review):
 
         Args:
             obj (M): The object to be reviewed and corrected. Must implement ProposedAble.
+            reference (str): A reference or contextual information for the object.
+            supervisor_check (bool, optional): Whether to perform a supervisor check on the review results. Defaults to True.
             **kwargs: Review configuration parameters including criteria and review options.
 
         Returns:
@@ -44,23 +52,27 @@ class Correct(Review):
         """
         if not isinstance(obj, (Display, WithBriefing)):
             raise TypeError(f"Expected Display or WithBriefing, got {type(obj)}")
+
         review_res = await self.review_obj(obj, **kwargs)
-        await review_res.supervisor_check()
+        if supervisor_check:
+            await review_res.supervisor_check()
         if "default" in kwargs:
-            kwargs["default"] = None
+            cast("ReviewKwargs[None]", kwargs)["default"] = None
         return await self.propose(
             obj.__class__,
             TEMPLATE_MANAGER.render_template(
                 configs.templates.correct_template,
                 {
-                    "content": obj.display() if isinstance(obj, Display) else obj.briefing,
+                    "content": f"{(reference + '\n\nAbove is referencing material') if reference else ''}{obj.display() if isinstance(obj, Display) else obj.briefing}",
                     "review": review_res.display(),
                 },
             ),
             **kwargs,
         )
 
-    async def correct_string(self, input_text: str, **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]]) -> Optional[str]:
+    async def correct_string(
+        self, input_text: str, supervisor_check: bool = True, **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]]
+    ) -> Optional[str]:
         """Review and correct a string based on defined criteria and templates.
 
         This method applies the review process to the input text and generates
@@ -68,16 +80,18 @@ class Correct(Review):
 
         Args:
             input_text (str): The text content to be reviewed and corrected.
+            supervisor_check (bool, optional): Whether to perform a supervisor check on the review results. Defaults to True.
             **kwargs: Review configuration parameters including criteria and review options.
 
         Returns:
             Optional[str]: The corrected text content, or None if correction fails.
         """
         review_res = await self.review_string(input_text, **kwargs)
-        await review_res.supervisor_check()
+        if supervisor_check:
+            await review_res.supervisor_check()
 
         if "default" in kwargs:
-            kwargs["default"] = None
+            cast("ReviewKwargs[None]", kwargs)["default"] = None
         return await self.ageneric_string(
             TEMPLATE_MANAGER.render_template(
                 configs.templates.correct_template, {"content": input_text, "review": review_res.display()}
@@ -86,7 +100,7 @@ class Correct(Review):
         )
 
     async def correct_task[T](
-        self, task: Task[T], **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]]
+        self, task: Task[T], **kwargs: Unpack[CorrectKwargs[ReviewResult[str]]]
     ) -> Optional[Task[T]]:
         """Review and correct a task object based on defined criteria.
 
@@ -101,3 +115,31 @@ class Correct(Review):
             Optional[Task[T]]: The corrected task, or None if correction fails.
         """
         return await self.correct_obj(task, **kwargs)
+
+    async def censor_obj[M: CensoredAble](
+        self, obj: M, **kwargs: Unpack[CensoredCorrectKwargs[ReviewResult[str]]]
+    ) -> M:
+        """Censor and correct an object based on defined criteria and templates.
+
+        Args:
+            obj (M): The object to be reviewed and corrected.
+            **kwargs (Unpack[CensoredCorrectKwargs]): Additional keyword
+
+        Returns:
+            M: The censored and corrected object.
+        """
+        last_modified_obj = obj
+        modified_obj = None
+        rprint(obj.finalized_dump())
+        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:
+                break
+            last_modified_obj = modified_obj
+            rprint(last_modified_obj.finalized_dump())
+        return modified_obj or last_modified_obj