fabricatio 0.2.6.dev7__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.7__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/_rust.pyi

@@ -11,7 +11,7 @@ class TemplateManager:
     """
 
     def __init__(
-            self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
+        self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
     ) -> None:
         """Initialize the template manager.
 
@@ -55,6 +55,16 @@ 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.
@@ -66,7 +76,6 @@ def blake3_hash(content: bytes) -> str:
         Hex-encoded BLAKE3 hash string
     """
 
-
 class BibManager:
     """BibTeX bibliography manager for parsing and querying citation data."""
 

fabricatio/actions/article.py

@@ -1,16 +1,17 @@
 """Actions for transmitting tasks to targets."""
 
-from os import PathLike
 from pathlib import Path
 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.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 questionary import confirm, text
-from rich import print as rprint
+from fabricatio.models.utils import ok
 
 
 class ExtractArticleEssence(Action):
@@ -24,10 +25,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:
@@ -51,18 +52,34 @@ 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 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)
 
 
 class GenerateOutline(Action):
@@ -76,35 +93,111 @@ class GenerateOutline(Action):
         article_proposal: ArticleProposal,
         **_,
     ) -> Optional[ArticleOutline]:
-        return await self.propose(
-            ArticleOutline,
-            article_proposal.display(),
-            system_message=f"# your personal briefing: \n{self.briefing}",
+        out = ok(
+            await self.propose(
+                ArticleOutline,
+                article_proposal.as_prompt(),
+                **self.prepend_sys_msg(),
+            ),
+            "Could not generate the outline.",
+        )
+
+        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 := out.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{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():
+            component, err = ok(pack)
+            logger.warning(f"Found illegal referring error: {err}")
+            corrected_metadata = ok(
+                await self.correct_obj(
+                    component.metadata,
+                    reference=f"# Original Article Outline\n{out.display()}\n# Error Need to be fixed\n{err}\n\n# Create a new metadata to handle the error.",
+                    topic=ref_topic,
+                    rating_manual=ref_manual,
+                    supervisor_check=False,
+                )
+            )
+            component.update_metadata(corrected_metadata)
+        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.")
+        )
+
+        for *_, subsec in article.iter_subsections():
+            corrected_subsec = await self.correct_obj(
+                subsec,
+                reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{subsec.introspect()}",
+                topic=w_topic,
+                rating_manual=write_para_manual,
+                supervisor_check=False,
+            )
+            subsec.paragraphs.clear()
+            subsec.paragraphs.extend(corrected_subsec.paragraphs)
+
+        logger.success(f"Finished: {article.display()}")
+        logger.success(f"Dump: {article.finalized_dump()}")
+        return article
+
 
 class CorrectProposal(Action):
     """Correct the proposal of the article."""
 
     output_key: str = "corrected_proposal"
 
-    async def _execute(self, task_input: Task, article_proposal: ArticleProposal, **_) -> Any:
-        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."
+    async def _execute(self, article_proposal: ArticleProposal, **_) -> Any:
+        return (await self.censor_obj(article_proposal, reference=article_proposal.referenced)).update_ref(
+            article_proposal
         )
 
-        ret = None
-        while await confirm("Do you want to correct the Proposal?").ask_async():
-            rprint(article_proposal.display())
-            while not (topic := await text("What is the topic of the proposal reviewing?").ask_async()):
-                ...
-            ret = await self.correct_obj(
-                article_proposal,
-                safe_text_read(input_path),
-                topic=topic,
-            )
-        return ret or article_proposal
-
 
 class CorrectOutline(Action):
     """Correct the outline of the article."""
@@ -115,14 +208,23 @@ class CorrectOutline(Action):
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        article_proposal: ArticleProposal,
+        **_,
+    ) -> 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,
         **_,
-    ) -> Optional[str]:
-        ret = None
-        while await confirm("Do you want to correct the outline?").ask_async():
-            rprint(article_outline.finalized_dump())
-            while not (topic := await text("What is the topic of the outline reviewing?").ask_async()):
-                ...
-            ret = await self.correct_obj(article_outline, article_proposal.display(), topic=topic)
-        return ret or article_outline
+    ) -> Article:
+        return await self.censor_obj(article, reference=article_outline.referenced.as_prompt())

fabricatio/actions/article_rag.py

@@ -0,0 +1,35 @@
+"""A module for writing articles using RAG (Retrieval-Augmented Generation) capabilities."""
+
+from typing import Optional
+
+from fabricatio.capabilities.rag import RAG
+from fabricatio.journal import logger
+from fabricatio.models.action import Action
+from fabricatio.models.extra.article_main import Article
+from fabricatio.models.extra.article_outline import ArticleOutline
+
+
+class GenerateArticleRAG(Action, RAG):
+    """Write an article based on the provided outline."""
+
+    output_key: str = "article"
+
+    async def _execute(self, article_outline: ArticleOutline, **cxt) -> Optional[Article]:
+        """Write an article based on the provided outline."""
+        logger.info(f"Writing an article based on the outline:\n{article_outline.title}")
+        refined_q = await self.arefined_query(article_outline.display())
+        return await self.propose(
+            Article,
+            article_outline.display(),
+            **self.prepend_sys_msg(f"{await self.aretrieve_compact(refined_q)}\n{self.briefing}"),
+        )
+
+
+class WriteArticleFineGrind(Action, RAG):
+    """Fine-grind an article based on the provided outline."""
+
+    output_key: str = "article"
+
+    async def _execute(self, article_outline: ArticleOutline, **cxt) -> Optional[Article]:
+        """Fine-grind an article based on the provided outline."""
+        logger.info(f"Fine-grinding an article based on the outline:\n{article_outline.title}")

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

@@ -10,9 +10,11 @@ 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 CorrectKwargs, 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):
@@ -55,7 +57,7 @@ class Correct(Review):
         if supervisor_check:
             await review_res.supervisor_check()
         if "default" in kwargs:
-            cast(ReviewKwargs[None], kwargs)["default"] = None
+            cast("ReviewKwargs[None]", kwargs)["default"] = None
         return await self.propose(
             obj.__class__,
             TEMPLATE_MANAGER.render_template(
@@ -89,7 +91,7 @@ class Correct(Review):
             await review_res.supervisor_check()
 
         if "default" in kwargs:
-            cast(ReviewKwargs[None], 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()}
@@ -113,3 +115,33 @@ 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

fabricatio/capabilities/rag.py

@@ -19,6 +19,7 @@ from fabricatio.models.kwargs_types import (
     EmbeddingKwargs,
     FetchKwargs,
     LLMKwargs,
+    RetrievalKwargs,
 )
 from fabricatio.models.usages import EmbeddingUsage
 from fabricatio.models.utils import MilvusData, ok
@@ -63,10 +64,18 @@ class RAG(EmbeddingUsage):
             uri=milvus_uri or ok(self.milvus_uri or configs.rag.milvus_uri).unicode_string(),
             token=milvus_token
             or (token.get_secret_value() if (token := (self.milvus_token or configs.rag.milvus_token)) else ""),
-            timeout=milvus_timeout or self.milvus_timeout,
+            timeout=milvus_timeout or self.milvus_timeout or configs.rag.milvus_timeout,
         )
         return self
 
+    def check_client(self, init: bool = True) -> Self:
+        """Check if the client is initialized, and if not, initialize it."""
+        if self._client is None and init:
+            return self.init_client()
+        if self._client is None and not init:
+            raise RuntimeError("Client is not initialized. Have you called `self.init_client()`?")
+        return self
+
     @overload
     async def pack(
         self, input_text: List[str], subject: Optional[str] = None, **kwargs: Unpack[EmbeddingKwargs]
@@ -111,8 +120,15 @@ class RAG(EmbeddingUsage):
             create (bool): Whether to create the collection if it does not exist.
             **kwargs (Unpack[CollectionConfigKwargs]): Additional keyword arguments for collection configuration.
         """
-        if create and collection_name and self.client.has_collection(collection_name):
-            kwargs["dimension"] = kwargs.get("dimension") or self.milvus_dimensions or configs.rag.milvus_dimensions
+        if create and collection_name and not self.check_client().client.has_collection(collection_name):
+            kwargs["dimension"] = ok(
+                kwargs.get("dimension")
+                or self.milvus_dimensions
+                or configs.rag.milvus_dimensions
+                or self.embedding_dimensions
+                or configs.embedding.dimensions,
+                "`dimension` is not set at any level.",
+            )
             self.client.create_collection(collection_name, auto_id=True, **kwargs)
             logger.info(f"Creating collection {collection_name}")
 
@@ -158,7 +174,7 @@ class RAG(EmbeddingUsage):
         else:
             raise TypeError(f"Expected MilvusData or list of MilvusData, got {type(data)}")
         c_name = collection_name or self.safe_target_collection
-        self.client.insert(c_name, prepared_data)
+        self.check_client().client.insert(c_name, prepared_data)
 
         if flush:
             logger.debug(f"Flushing collection {c_name}")
@@ -198,6 +214,25 @@ class RAG(EmbeddingUsage):
         self.add_document(await self.pack(text), collection_name or self.safe_target_collection, flush=True)
         return self
 
+    @overload
+    async def afetch_document[V: (int, str, float, bytes)](
+        self,
+        vecs: List[List[float]],
+        desired_fields: List[str],
+        collection_name: Optional[str] = None,
+        similarity_threshold: float = 0.37,
+        result_per_query: int = 10,
+    ) -> List[Dict[str, V]]: ...
+
+    @overload
+    async def afetch_document[V: (int, str, float, bytes)](
+        self,
+        vecs: List[List[float]],
+        desired_fields: str,
+        collection_name: Optional[str] = None,
+        similarity_threshold: float = 0.37,
+        result_per_query: int = 10,
+    ) -> List[V]: ...
     async def afetch_document[V: (int, str, float, bytes)](
         self,
         vecs: List[List[float]],
@@ -219,7 +254,7 @@ class RAG(EmbeddingUsage):
             List[Dict[str, Any]] | List[Any]: The retrieved data.
         """
         # Step 1: Search for vectors
-        search_results = self.client.search(
+        search_results = self.check_client().client.search(
             collection_name or self.safe_target_collection,
             vecs,
             search_params={"radius": similarity_threshold},
@@ -260,7 +295,7 @@ class RAG(EmbeddingUsage):
         if isinstance(query, str):
             query = [query]
         return cast(
-            List[str],
+            "List[str]",
             await self.afetch_document(
                 vecs=(await self.vectorize(query)),
                 desired_fields="text",
@@ -268,6 +303,24 @@ class RAG(EmbeddingUsage):
             ),
         )[:final_limit]
 
+    async def aretrieve_compact(
+        self,
+        query: List[str] | str,
+        **kwargs: Unpack[RetrievalKwargs],
+    ) -> str:
+        """Retrieve data from the collection and format it for display.
+
+        Args:
+            query (List[str] | str): The query to be used for retrieval.
+            **kwargs (Unpack[RetrievalKwargs]): Additional keyword arguments for retrieval.
+
+        Returns:
+            str: A formatted string containing the retrieved data.
+        """
+        return TEMPLATE_MANAGER.render_template(
+            configs.templates.retrieved_display_template, {"docs": (await self.aretrieve(query, **kwargs))}
+        )
+
     async def aask_retrieved(
         self,
         question: str,
@@ -298,16 +351,14 @@ class RAG(EmbeddingUsage):
         Returns:
             str: A string response generated after asking with the context of retrieved documents.
         """
-        docs = await self.aretrieve(
+        rendered = await self.aretrieve_compact(
             query or question,
-            final_limit,
+            final_limit=final_limit,
             collection_name=collection_name,
             result_per_query=result_per_query,
             similarity_threshold=similarity_threshold,
         )
 
-        rendered = TEMPLATE_MANAGER.render_template(configs.templates.retrieved_display_template, {"docs": docs[::-1]})
-
         logger.debug(f"Retrieved Documents: \n{rendered}")
         return await self.aask(
             question,