fabricatio 0.2.11.dev3__cp312-cp312-win_amd64.whl → 0.2.12.dev2__cp312-cp312-win_amd64.whl

fabricatio/actions/article_rag.py

@@ -4,7 +4,10 @@ from asyncio import gather
 from pathlib import Path
 from typing import List, Optional
 
+from pydantic import Field, PositiveInt
+
 from fabricatio import BibManager
+from fabricatio.capabilities.advanced_rag import AdvancedRAG
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.extract import Extract
 from fabricatio.capabilities.rag import RAG
@@ -16,59 +19,63 @@ from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article, ArticleChapter, ArticleSection, ArticleSubsection
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.rule import RuleSet
+from fabricatio.models.kwargs_types import ChooseKwargs, LLMKwargs
 from fabricatio.utils import ask_retain, ok
 
+TYPST_CITE_USAGE = (
+    "citation number is REQUIRED to cite any reference!,for example in Auther Pattern: 'Doe et al.[[1]], Jack et al.[[2]]' or in Sentence Suffix Sattern: 'Global requirement is incresing[[1]].'\n"
+    "Everything is build upon the typst language, which is similar to latex, \n"
+    "Legal citing syntax examples(seperated by |): [[1]]|[[1,2]]|[[1-3]]|[[12,13-15]]|[[1-3,5-7]]\n"
+    "Illegal citing syntax examples(seperated by |): [[1],[2],[3]]|[[1],[1-2]]\n"
+    "Those reference mark shall not be omitted during the extraction\n"
+    "It's recommended to cite multiple references that supports your conclusion at a time.\n"
+    "Wrap inline expression with '\\(' and '\\)',like '\\(>5m\\)' '\\(89%\\)', and wrap block equation with '\\[' and '\\]'.\n"
+    "In addition to that, you can add a label outside the block equation which can be used as a cross reference identifier, the label is a string wrapped in `<` and `>` like `<energy-release-rate-equation>`.Note that the label string should be a summarizing title for the equation being labeled.\n"
+    "you can refer to that label by using the syntax with prefix of `@eqt:`, which indicate that this notation is citing a label from the equations. For example ' @eqt:energy-release-rate-equation ' DO remember that the notation shall have both suffixed and prefixed space char which enable the compiler to distinguish the notation from the plaintext."
+    "Below is two usage example:\n"
+    "```typst\n"
+    "See @eqt:mass-energy-equation , it's the foundation of physics.\n"
+    "\\[\n"
+    "E = m c^2\n"
+    "\\]  <mass-energy-equation>\n\n\n"
+    "In @eqt:mass-energy-equation , \\(m\\) stands for mass, \\(c\\) stands for speed of light, and \\(E\\) stands for energy. \n"
+    "```\n"
+)
+
 
 class WriteArticleContentRAG(Action, RAG, Extract):
     """Write an article based on the provided outline."""
 
+    search_increment_multiplier: float = 1.6
+    """The increment multiplier of the search increment."""
     ref_limit: int = 35
     """The limit of references to be retrieved"""
-    threshold: float = 0.55
+    threshold: float = 0.62
     """The threshold of relevance"""
-    extractor_model: str
+    extractor_model: LLMKwargs
     """The model to use for extracting the content from the retrieved references."""
-    query_model: str
+    query_model: LLMKwargs
     """The model to use for querying the database"""
     supervisor: bool = False
     """Whether to use supervisor mode"""
-    req: str = (
-        "citation number is REQUIRED to cite any reference!\n"
-        "Everything is build upon the typst language, which is similar to latex, \n"
-        "Legal citing syntax examples(seperated by |): [[1]]|[[1,2]]|[[1-3]]|[[12,13-15]]|[[1-3,5-7]]\n"
-        "Illegal citing syntax examples(seperated by |): [[1],[2],[3]]|[[1],[1-2]]\n"
-        "Those reference mark shall not be omitted during the extraction\n"
-        "It's recommended to cite multiple references that supports your conclusion at a time.\n"
-        "Wrapp inline expression using $ $, and wrapp block equation using $$ $$."
-        "In addition to that, you can add a label outside the block equation which can be used as a cross reference identifier, the label is a string wrapped in `<` and `>`,"
-        "you can refer to that label by using the syntax with prefix of `@eqt:`"
-        "Below is a usage example:\n"
-        "```typst\n"
-        "See @eqt:mass-energy-equation , it's the foundation of physics.\n"
-        "$$\n"
-        "E = m c^2"
-        "$$\n"
-        "<mass-energy-equation>\n\n"
-        "In @eqt:mass-energy-equation , $m$ stands for mass, $c$ stands for speed of light, and $E$ stands for energy. \n"
-        "```"
-    )
+    result_per_query: PositiveInt = 4
+    """The number of results to be returned per query."""
+    req: str = TYPST_CITE_USAGE
+    """The req of the write article content."""
 
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        collection_name: str = "article_chunks",
+        collection_name: Optional[str] = None,
         supervisor: Optional[bool] = None,
         **cxt,
     ) -> Article:
         article = Article.from_outline(article_outline).update_ref(article_outline)
-
+        self.target_collection = collection_name or self.safe_target_collection
         if supervisor or (supervisor is None and self.supervisor):
-            await gather(
-                *[
-                    self._supervisor_inner(article, article_outline, chap, sec, subsec)
-                    for chap, sec, subsec in article.iter_subsections()
-                ]
-            )
+            for chap, sec, subsec in article.iter_subsections():
+                await self._supervisor_inner(article, article_outline, chap, sec, subsec)
+
         else:
             await gather(
                 *[
@@ -92,22 +99,29 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         from questionary import confirm, text
         from rich import print as r_print
 
-        ret = await self.search_database(article, article_outline, chap, sec, subsec)
-
-        cm = CitationManager(article_chunks=await ask_retain([r.chunk for r in ret], ret)).set_cite_number_all()
+        cm = CitationManager()
+        await self.search_database(article, article_outline, chap, sec, subsec, cm)
 
         raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm)
         r_print(raw)
 
         while not await confirm("Accept this version and continue?").ask_async():
-            if await confirm("Search for more refs?").ask_async():
-                new_refs = await self.search_database(article, article_outline, chap, sec, subsec, supervisor=True)
-                cm.add_chunks(await ask_retain([r.chunk for r in new_refs], new_refs))
+            if inst := await text("Search for more refs for additional spec.").ask_async():
+                await self.search_database(
+                    article,
+                    article_outline,
+                    chap,
+                    sec,
+                    subsec,
+                    cm,
+                    supervisor=True,
+                    extra_instruction=inst,
+                )
 
-            instruction = await text("Enter the instructions to improve").ask_async()
-            raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm, instruction)
-            if await confirm("Edit it?").ask_async():
-                raw = await text("Edit", default=raw).ask_async() or raw
+            if instruction := await text("Enter the instructions to improve").ask_async():
+                raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm, instruction)
+            if edt := await text("Edit", default=raw).ask_async():
+                raw = edt
 
             r_print(raw)
 
@@ -121,11 +135,14 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         sec: ArticleSection,
         subsec: ArticleSubsection,
     ) -> ArticleSubsection:
-        ret = await self.search_database(article, article_outline, chap, sec, subsec)
-        cm = CitationManager(article_chunks=ret).set_cite_number_all()
+        cm = CitationManager()
+
+        await self.search_database(article, article_outline, chap, sec, subsec, cm)
 
         raw_paras = await self.write_raw(article, article_outline, chap, sec, subsec, cm)
 
+        raw_paras = "\n".join(p for p in raw_paras.splitlines() if p and not p.endswith("**") and not p.startswith("#"))
+
         return await self.extract_new_subsec(subsec, raw_paras, cm)
 
     async def extract_new_subsec(
@@ -139,11 +156,12 @@ class WriteArticleContentRAG(Action, RAG, Extract):
                 f"Above is the subsection titled `{subsec.title}`.\n"
                 f"I need you to extract the content to update my subsection obj provided below.\n{self.req}"
                 f"{subsec.display()}\n",
+                **self.extractor_model,
             ),
             "Failed to propose new subsection.",
         )
         for p in new_subsec.paragraphs:
-            p.content = cm.apply(p.content).replace("$$", "\n$$\n")
+            p.content = cm.apply(p.content)
         subsec.update_from(new_subsec)
         logger.debug(f"{subsec.title}:rpl\n{subsec.display()}")
         return subsec
@@ -159,23 +177,16 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         extra_instruction: str = "",
     ) -> str:
         """Write the raw paragraphs of the subsec."""
-        return (
-            (
-                await self.aask(
-                    f"{cm.as_prompt()}\nAbove is some related reference retrieved for you."
-                    f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
-                    f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
-                    f"Please help me write the paragraphs of the subsec mentioned above, which is `{subsec.title}`.\n"
-                    f"{self.req}\n"
-                    f"You SHALL use `{article.language}` as writing language.\n{extra_instruction}"
-                )
-            )
-            .replace(r" \( ", "$")
-            .replace(r" \) ", "$")
-            .replace(r"\(", "$")
-            .replace(r"\)", "$")
-            .replace("\\[\n", "$$\n")
-            .replace("\n\\]", "\n$$")
+        return await self.aask(
+            f"{cm.as_prompt()}\nAbove is some related reference from other auther retrieved for you."
+            f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
+            f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
+            f"Please help me write the paragraphs of the subsec mentioned above, which is `{subsec.title}`.\n"
+            f"{self.req}\n"
+            f"You SHALL use `{article.language}` as writing language.\n{extra_instruction}\n"
+            f"Do not use numbered list to display the outcome, you should regard you are writing the main text of the thesis.\n"
+            f"You should not copy others' works from the references directly on to my thesis, we can only harness the conclusion they have drawn.\n"
+            f"No extra explanation is allowed."
         )
 
     async def search_database(
@@ -185,28 +196,117 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         chap: ArticleChapter,
         sec: ArticleSection,
         subsec: ArticleSubsection,
+        cm: CitationManager,
         extra_instruction: str = "",
         supervisor: bool = False,
-    ) -> List[ArticleChunk]:
+    ) -> None:
         """Search database for related references."""
+        search_req = (
+            f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
+            f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
+            f"I need to search related references to build up the content of the subsec mentioned above, which is `{subsec.title}`.\n"
+            f"provide 10~16 queries as possible, to get best result!\n"
+            f"You should provide both English version and chinese version of the refined queries!\n{extra_instruction}\n"
+        )
+
         ref_q = ok(
             await self.arefined_query(
-                f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
-                f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
-                f"I need to search related references to build up the content of the subsec mentioned above, which is `{subsec.title}`.\n"
-                f"provide 10~16 queries as possible, to get best result!\n"
-                f"You should provide both English version and chinese version of the refined queries!\n{extra_instruction}\n",
-                model=self.query_model,
+                search_req,
+                **self.query_model,
             ),
             "Failed to refine query.",
         )
 
+        if supervisor:
+            ref_q = await ask_retain(ref_q)
+        ret = await self.aretrieve(
+            ref_q,
+            ArticleChunk,
+            max_accepted=self.ref_limit,
+            result_per_query=self.result_per_query,
+            similarity_threshold=self.threshold,
+        )
+
+        cm.add_chunks(ok(ret))
+        ref_q = await self.arefined_query(
+            f"{cm.as_prompt()}\n\nAbove is the retrieved references in the first RAG, now we need to perform the second RAG.\n\n{search_req}",
+            **self.query_model,
+        )
+
+        if ref_q is None:
+            logger.warning("Second refine query is None, skipping.")
+            return
         if supervisor:
             ref_q = await ask_retain(ref_q)
 
-        return await self.aretrieve(
-            ref_q, ArticleChunk, final_limit=self.ref_limit, result_per_query=3, similarity_threshold=self.threshold
+        ret = await self.aretrieve(
+            ref_q,
+            ArticleChunk,
+            max_accepted=int(self.ref_limit * self.search_increment_multiplier),
+            result_per_query=int(self.result_per_query * self.search_increment_multiplier),
+            similarity_threshold=self.threshold,
         )
+        if ret is None:
+            logger.warning("Second retrieve is None, skipping.")
+            return
+        cm.add_chunks(ret)
+
+
+class ArticleConsultRAG(Action, AdvancedRAG):
+    """Write an article based on the provided outline."""
+
+    output_key: str = "consult_count"
+    search_increment_multiplier: float = 1.6
+    """The multiplier to increase the limit of references to retrieve per query."""
+    ref_limit: int = 20
+    """The final limit of references."""
+    ref_per_q: int = 3
+    """The limit of references to retrieve per query."""
+    similarity_threshold: float = 0.62
+    """The similarity threshold of references to retrieve."""
+    ref_q_model: ChooseKwargs = Field(default_factory=ChooseKwargs)
+    """The model to use for refining query."""
+    req: str = TYPST_CITE_USAGE
+    """The request for the rag model."""
+
+    @precheck_package(
+        "questionary", "`questionary` is required for supervisor mode, please install it by `fabricatio[qa]`"
+    )
+    async def _execute(self, collection_name: Optional[str] = None, **cxt) -> int:
+        from questionary import confirm, text
+        from rich import print as r_print
+
+        from fabricatio.rust import convert_all_block_tex, convert_all_inline_tex, fix_misplaced_labels
+
+        self.target_collection = collection_name or self.safe_target_collection
+
+        cm = CitationManager()
+
+        counter = 0
+        while (req := await text("User: ").ask_async()) is not None:
+            if await confirm("Empty the cm?").ask_async():
+                cm.empty()
+            await self.clued_search(
+                req,
+                cm,
+                refinery_kwargs=self.ref_q_model,
+                expand_multiplier=self.search_increment_multiplier,
+                base_accepted=self.ref_limit,
+                result_per_query=self.ref_per_q,
+                similarity_threshold=self.similarity_threshold,
+            )
+
+            ret = await self.aask(f"{cm.as_prompt()}\n{self.req}\n{req}")
+
+            ret = fix_misplaced_labels(ret)
+            ret = convert_all_inline_tex(ret)
+            ret = convert_all_block_tex(ret)
+            ret = cm.apply(ret)
+
+            r_print(ret)
+            counter += 1
+        logger.info(f"{counter} rounds of conversation.")
+        return counter
 
 
 class TweakArticleRAG(Action, RAG, Censor):
@@ -290,7 +390,7 @@ class TweakArticleRAG(Action, RAG, Censor):
         await self.censor_obj_inplace(
             subsec,
             ruleset=ruleset,
-            reference=f"{'\n\n'.join(d.display() for d in await self.aretrieve(refind_q, document_model=ArticleEssence, final_limit=self.ref_limit))}\n\n"
+            reference=f"{'\n\n'.join(d.display() for d in await self.aretrieve(refind_q, document_model=ArticleEssence, max_accepted=self.ref_limit))}\n\n"
             f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
             f"You should Always use `{subsec.language}` as written language, "
             f"which is the original language of the `{subsec.title}`. "

fabricatio/actions/output.py

@@ -3,14 +3,17 @@
 from pathlib import Path
 from typing import Any, Iterable, List, Mapping, Optional, Type
 
+from fabricatio import TEMPLATE_MANAGER
+from fabricatio.fs import dump_text
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.generic import FinalizedDumpAble, FromMapping, PersistentAble
 from fabricatio.models.task import Task
+from fabricatio.models.usages import LLMUsage
 from fabricatio.utils import ok
 
 
-class DumpFinalizedOutput(Action):
+class DumpFinalizedOutput(Action, LLMUsage):
     """Dump the finalized output to a file."""
 
     output_key: str = "dump_path"
@@ -38,7 +41,45 @@ class DumpFinalizedOutput(Action):
         return dump_path.as_posix()
 
 
-class PersistentAll(Action):
+class RenderedDump(Action, LLMUsage):
+    """Render the data to a file."""
+
+    output_key: str = "dump_path"
+    dump_path: Optional[str] = None
+
+    template_name: str
+    """The template name to render 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 self.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.",
+            )
+        )
+
+        logger.info(f"Saving output to {dump_path.as_posix()}")
+        dump_text(
+            dump_path,
+            TEMPLATE_MANAGER.render_template(
+                self.template_name, {to_dump.__class__.__name__: to_dump.finalized_dump()}
+            ),
+        )
+
+        return dump_path.as_posix()
+
+
+class PersistentAll(Action, LLMUsage):
     """Persist all the data to a file."""
 
     output_key: str = "persistent_count"

fabricatio/capabilities/advanced_rag.py

@@ -0,0 +1,53 @@
+"""Advanced RAG (Retrieval Augmented Generation) model."""
+
+from typing import Optional, Unpack
+
+from fabricatio.capabilities.rag import RAG
+from fabricatio.journal import logger
+from fabricatio.models.adv_kwargs_types import FetchKwargs
+from fabricatio.models.extra.aricle_rag import ArticleChunk, CitationManager
+from fabricatio.models.kwargs_types import ChooseKwargs
+
+
+class AdvancedRAG(RAG):
+    """A class representing the Advanced RAG (Retrieval Augmented Generation) model."""
+    async def clued_search(
+        self,
+        requirement: str,
+        cm: CitationManager,
+        max_capacity=40,
+        max_round: int = 3,
+        expand_multiplier: float = 1.4,
+        base_accepted: int = 12,
+        refinery_kwargs: Optional[ChooseKwargs] = None,
+        **kwargs: Unpack[FetchKwargs],
+    ) -> CitationManager:
+        """Asynchronously performs a clued search based on a given requirement and citation manager."""
+        if max_round < 2:
+            logger.warning(
+                "max_round should be greater than 1, otherwise it behaves nothing different from the `self.aretrieve`"
+            )
+
+        refinery_kwargs = refinery_kwargs or {}
+
+        for i in range(max_round + 1, 1):
+            logger.info(f"Round [{i + 1}/{max_round}] search started.")
+            ref_q = await self.arefined_query(
+                f"{cm.as_prompt()}\n\nAbove is the retrieved references in the {i - 1}th RAG, now we need to perform the {i}th RAG."
+                f"\n\n{requirement}",
+                **refinery_kwargs,
+            )
+            if ref_q is None:
+                logger.error(f"At round [{i + 1}/{max_round}] search, failed to refine the query, exit.")
+                return cm
+            refs = await self.aretrieve(ref_q, ArticleChunk, base_accepted, **kwargs)
+
+            if (max_capacity := max_capacity - len(refs)) < 0:
+                cm.add_chunks(refs[0:max_capacity])
+                logger.debug(f"At round [{i + 1}/{max_round}] search, the capacity is not enough, exit.")
+                return cm
+
+            cm.add_chunks(refs)
+            base_accepted = int(base_accepted * expand_multiplier)
+        logger.debug(f"Exceeded max_round: {max_round}, exit.")
+        return cm

fabricatio/capabilities/rag.py

@@ -189,7 +189,7 @@ class RAG(EmbeddingUsage):
         self,
         query: List[str] | str,
         document_model: Type[D],
-        final_limit: int = 20,
+        max_accepted: int = 20,
         **kwargs: Unpack[FetchKwargs],
     ) -> List[D]:
         """Retrieve data from the collection.
@@ -197,7 +197,7 @@ class RAG(EmbeddingUsage):
         Args:
             query (List[str] | str): The query to be used for retrieval.
             document_model (Type[D]): The model class used to convert retrieved data into document objects.
-            final_limit (int): The final limit on the number of results to return.
+            max_accepted (int): The final limit on the number of results to return.
             **kwargs (Unpack[FetchKwargs]): Additional keyword arguments for retrieval.
 
         Returns:
@@ -211,9 +211,9 @@ class RAG(EmbeddingUsage):
                 document_model=document_model,
                 **kwargs,
             )
-        )[:final_limit]
+        )[:max_accepted]
 
-    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs]) -> Optional[List[str]]:
+    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs[Optional[List[str]]]]) -> Optional[List[str]]:
         """Refines the given question using a template.
 
         Args:

fabricatio/config.py

@@ -328,9 +328,9 @@ class RoutingConfig(BaseModel):
     allowed_fails: Optional[int] = 3
     """The number of allowed fails before the routing is considered failed."""
     retry_after: int = 15
-    """The time in seconds to wait before retrying the routing after a fail."""
-    cooldown_time: Optional[int] = 30
-    """The time in seconds to wait before retrying the routing after a cooldown."""
+    """Minimum time to wait before retrying a failed request."""
+    cooldown_time: Optional[int] = 60
+    """Time to cooldown a deployment after failure in seconds."""
 
 
 class Settings(BaseSettings):

fabricatio/fs/curd.py

@@ -20,7 +20,7 @@ def dump_text(path: Union[str, Path], text: str) -> None:
     Returns:
         None
     """
-    Path(path).write_text(text, encoding="utf-8", errors="ignore")
+    Path(path).write_text(text, encoding="utf-8", errors="ignore", newline="\n")
 
 
 def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:

fabricatio/models/action.py

@@ -12,12 +12,12 @@ Classes:
 import traceback
 from abc import abstractmethod
 from asyncio import Queue, create_task
-from typing import Any, Dict, Self, Tuple, Type, Union, final
+from typing import Any, Dict, Self, Sequence, Tuple, Type, Union, final
 
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.task import Task
-from fabricatio.models.usages import LLMUsage, ToolBoxUsage
+from fabricatio.models.usages import ToolBoxUsage
 from fabricatio.utils import override_kwargs
 from pydantic import Field, PrivateAttr
 
@@ -26,7 +26,7 @@ OUTPUT_KEY = "task_output"
 INPUT_KEY = "task_input"
 
 
-class Action(WithBriefing, LLMUsage):
+class Action(WithBriefing):
     """Class that represents an action to be executed in a workflow.
 
     Actions are the atomic units of work in a workflow. Each action performs
@@ -96,9 +96,9 @@ class Action(WithBriefing, LLMUsage):
             return f"## Your personality: \n{self.personality}\n# The action you are going to perform: \n{super().briefing}"
         return f"# The action you are going to perform: \n{super().briefing}"
 
-    def to_task_output(self) -> Self:
+    def to_task_output(self, task_output_key: str = OUTPUT_KEY) -> Self:
         """Set the output key to OUTPUT_KEY and return the action instance."""
-        self.output_key = OUTPUT_KEY
+        self.output_key = task_output_key
         return self
 
 
@@ -123,9 +123,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
     """Instantiated action objects to be executed in this workflow."""
 
-    steps: Tuple[Union[Type[Action], Action], ...] = Field(
-        frozen=True,
-    )
+    steps: Sequence[Union[Type[Action], Action]] = Field(frozen=True)
     """The sequence of actions to be executed, can be action classes or instances."""
 
     task_input_key: str = Field(default=INPUT_KEY)

fabricatio/models/extra/aricle_rag.py

@@ -9,7 +9,7 @@ from fabricatio.journal import logger
 from fabricatio.models.extra.rag import MilvusDataBase
 from fabricatio.models.generic import AsPrompt
 from fabricatio.models.kwargs_types import ChunkKwargs
-from fabricatio.rust import BibManager, is_chinese, split_into_chunks
+from fabricatio.rust import BibManager, blake3_hash, split_into_chunks
 from fabricatio.utils import ok
 from more_itertools.recipes import flatten, unique
 from pydantic import Field
@@ -53,7 +53,7 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
 
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {
-            f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}`": self.chunk
+            f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}` from {self.as_auther_seq()}": self.chunk
         }
 
     @property
@@ -139,15 +139,9 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
         return re.sub(r"\[[\d\s,\\~–-]+]", "", string)
 
     @property
-    def auther_firstnames(self) -> List[str]:
-        """Get the first name of the authors."""
-        ret = []
-        for n in self.authors:
-            if is_chinese(n):
-                ret.append(n[0])
-            else:
-                ret.append(n.split()[-1])
-        return ret
+    def auther_lastnames(self) -> List[str]:
+        """Get the last name of the authors."""
+        return [n.split()[-1] for n in self.authors]
 
     def as_auther_seq(self) -> str:
         """Get the auther sequence."""
@@ -155,13 +149,13 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
             case 0:
                 raise ValueError("No authors found")
             case 1:
-                return f"（{self.auther_firstnames[0]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.year}）{self.as_typst_cite()}"
             case 2:
-                return f"（{self.auther_firstnames[0]}{self.and_word}{self.auther_firstnames[1]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}{self.and_word}{self.auther_lastnames[1]}，{self.year}）{self.as_typst_cite()}"
             case 3:
-                return f"（{self.auther_firstnames[0]}，{self.auther_firstnames[1]}{self.and_word}{self.auther_firstnames[2]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.auther_lastnames[1]}{self.and_word}{self.auther_lastnames[2]}，{self.year}）{self.as_typst_cite()}"
             case _:
-                return f"（{self.auther_firstnames[0]}，{self.auther_firstnames[1]}{self.and_word}{self.auther_firstnames[2]}{self.etc_word}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.auther_lastnames[1]}{self.and_word}{self.auther_lastnames[2]}{self.etc_word}，{self.year}）{self.as_typst_cite()}"
 
     def update_cite_number(self, cite_number: int) -> Self:
         """Update the cite number."""
@@ -182,20 +176,32 @@ class CitationManager(AsPrompt):
     abbr_sep: str = "-"
     """Separator for abbreviated citation numbers."""
 
-    def update_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True) -> Self:
+    def update_chunks(
+        self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True
+    ) -> Self:
         """Update article chunks."""
         self.article_chunks.clear()
         self.article_chunks.extend(article_chunks)
+        if dedup:
+            self.article_chunks = list(unique(self.article_chunks, lambda c: blake3_hash(c.chunk.encode())))
         if set_cite_number:
             self.set_cite_number_all()
         return self
 
-    def add_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True)-> Self:
+    def empty(self) -> Self:
+        """Empty the article chunks."""
+        self.article_chunks.clear()
+        return self
+
+    def add_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True) -> Self:
         """Add article chunks."""
         self.article_chunks.extend(article_chunks)
+        if dedup:
+            self.article_chunks = list(unique(self.article_chunks, lambda c: blake3_hash(c.chunk.encode())))
         if set_cite_number:
             self.set_cite_number_all()
         return self
+
     def set_cite_number_all(self) -> Self:
         """Set citation numbers for all article chunks."""
         for i, a in enumerate(self.article_chunks, 1):
@@ -208,7 +214,7 @@ class CitationManager(AsPrompt):
 
     def apply(self, string: str) -> str:
         """Apply citation replacements to the input string."""
-        for origin,m in re.findall(self.pat, string):
+        for origin, m in re.findall(self.pat, string):
             logger.info(f"Matching citation: {m}")
             notations = self.convert_to_numeric_notations(m)
             logger.info(f"Citing Notations: {notations}")
@@ -216,9 +222,26 @@ class CitationManager(AsPrompt):
             logger.info(f"Citation Number Sequence: {citation_number_seq}")
             dedup = self.deduplicate_citation(citation_number_seq)
             logger.info(f"Deduplicated Citation Number Sequence: {dedup}")
-            string=string.replace(origin, self.unpack_cite_seq(dedup))
+            string = string.replace(origin, self.unpack_cite_seq(dedup))
         return string
 
+    def citation_count(self, string: str) -> int:
+        """Get the citation count in the string."""
+        count = 0
+        for _, m in re.findall(self.pat, string):
+            logger.info(f"Matching citation: {m}")
+            notations = self.convert_to_numeric_notations(m)
+            logger.info(f"Citing Notations: {notations}")
+            citation_number_seq = list(flatten(self.decode_expr(n) for n in notations))
+            logger.info(f"Citation Number Sequence: {citation_number_seq}")
+            count += len(dedup := self.deduplicate_citation(citation_number_seq))
+            logger.info(f"Deduplicated Citation Number Sequence: {dedup}")
+        return count
+
+    def citation_coverage(self, string: str) -> float:
+        """Get the citation coverage in the string."""
+        return self.citation_count(string) / len(self.article_chunks)
+
     def decode_expr(self, string: str) -> List[int]:
         """Decode citation expression into a list of integers."""
         if self.abbr_sep in string:

fabricatio/models/extra/article_base.py

@@ -46,6 +46,16 @@ class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
     aims: List[str]
     """List of writing aims of the research component in academic style."""
 
+    @property
+    def typst_metadata_comment(self) -> str:
+        """Generates a comment for the metadata of the article component."""
+        return comment(
+            (f"Desc:\n  {self.description}\n" if self.description else "")
+            + (f"Aims:\n  {'\n  '.join(self.aims)}\n" if self.aims else "")
+            + (f"Expected Word Count:{self.expected_word_count}" if self.expected_word_count else "")
+
+        )
+
 
 class ArticleOutlineBase(
     ArticleMetaData,
@@ -89,13 +99,7 @@ class SubSectionBase(ArticleOutlineBase):
 
     def to_typst_code(self) -> str:
         """Converts the component into a Typst code snippet for rendering."""
-        return (
-            f"=== {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        )
+        return f"=== {self.title}\n{self.typst_metadata_comment}\n"
 
     def introspect(self) -> str:
         """Introspects the article subsection outline."""
@@ -120,13 +124,9 @@ class SectionBase[T: SubSectionBase](ArticleOutlineBase):
         Returns:
             str: The formatted Typst code snippet.
         """
-        return (
-            f"== {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
+        return f"== {self.title}\n{self.typst_metadata_comment}\n" + "\n\n".join(
+            subsec.to_typst_code() for subsec in self.subsections
+        )
 
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
@@ -169,13 +169,9 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
 
     def to_typst_code(self) -> str:
         """Converts the chapter into a Typst formatted code snippet for rendering."""
-        return (
-            f"= {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(sec.to_typst_code() for sec in self.sections)
+        return f"= {self.title}\n{self.typst_metadata_comment}\n" + "\n\n".join(
+            sec.to_typst_code() for sec in self.sections
+        )
 
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
@@ -317,8 +313,41 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Descri
             === Implementation Details
             == Evaluation Protocol
         """
-        return comment(
-            f"Title:{self.title}\nDesc:\n{self.description}\n" + f"Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(a.to_typst_code() for a in self.chapters)
+        return (
+            comment(
+                f"Title:{self.title}\n"
+                + (f"Desc:\n{self.description}\n" if self.description else "")
+                + f"Word Count:{self.expected_word_count}"
+                if self.expected_word_count
+                else ""
+            )
+            + "\n\n"
+            + "\n\n".join(a.to_typst_code() for a in self.chapters)
+        )
+
+    def avg_chap_wordcount[S](self: S) -> S:
+        """Set all chap have same word count sum up to be `self.expected_word_count`."""
+        avg = int(self.expected_word_count / len(self.chapters))
+        for c in self.chapters:
+            c.expected_word_count = avg
+        return self
+
+    def avg_sec_wordcount[S](self: S) -> S:
+        """Set all sec have same word count sum up to be `self.expected_word_count`."""
+        for c in self.chapters:
+            avg = int(c.expected_word_count / len(c.sections))
+            for s in c.sections:
+                s.expected_word_count = avg
+        return self
+
+    def avg_subsec_wordcount[S](self: S) -> S:
+        """Set all subsec have same word count sum up to be `self.expected_word_count`."""
+        for _, s in self.iter_sections():
+            avg = int(s.expected_word_count / len(s.subsections))
+            for ss in s.subsections:
+                ss.expected_word_count = avg
+        return self
+
+    def avg_wordcount_recursive[S](self:S) -> S:
+        """Set all chap, sec, subsec have same word count sum up to be `self.expected_word_count`."""
+        return self.avg_chap_wordcount().avg_sec_wordcount().avg_subsec_wordcount()

fabricatio/models/extra/article_main.py

@@ -12,10 +12,14 @@ from fabricatio.models.extra.article_base import (
     SubSectionBase,
 )
 from fabricatio.models.extra.article_outline import (
+    ArticleChapterOutline,
     ArticleOutline,
+    ArticleSectionOutline,
+    ArticleSubsectionOutline,
 )
 from fabricatio.models.generic import Described, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
-from fabricatio.rust import convert_all_block_tex, convert_all_inline_tex, word_count
+from fabricatio.rust import convert_all_block_tex, convert_all_inline_tex, fix_misplaced_labels, word_count
+from fabricatio.utils import fallback_kwargs
 from pydantic import Field, NonNegativeInt
 
 PARAGRAPH_SEP = "// - - -"
@@ -89,7 +93,7 @@ class ArticleSubsection(SubSectionBase):
         Returns:
             str: Typst code snippet for rendering.
         """
-        return f"=== {self.title}\n" + f"\n{PARAGRAPH_SEP}\n".join(p.content for p in self.paragraphs)
+        return super().to_typst_code() + f"\n\n{PARAGRAPH_SEP}\n\n".join(p.content for p in self.paragraphs)
 
     @classmethod
     def from_typst_code(cls, title: str, body: str) -> Self:
@@ -161,6 +165,7 @@ class Article(
         """Convert tex to typst code."""
         for _, _, subsec in self.iter_subsections():
             for p in subsec.paragraphs:
+                p.content = fix_misplaced_labels(p.content)
                 p.content = convert_all_inline_tex(p.content)
                 p.content = convert_all_block_tex(p.content)
         return self
@@ -181,6 +186,50 @@ class Article(
     def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
         return super().iter_subsections()  # pyright: ignore [reportReturnType]
 
+    def extrac_outline(self) -> ArticleOutline:
+        """Extract outline from article."""
+        # Create an empty list to hold chapter outlines
+        chapters = []
+
+        # Iterate through each chapter in the article
+        for chapter in self.chapters:
+            # Create an empty list to hold section outlines
+            sections = []
+
+            # Iterate through each section in the chapter
+            for section in chapter.sections:
+                # Create an empty list to hold subsection outlines
+                subsections = []
+
+                # Iterate through each subsection in the section
+                for subsection in section.subsections:
+                    # Create a subsection outline and add it to the list
+                    subsections.append(
+                        ArticleSubsectionOutline(**subsection.model_dump(exclude={"paragraphs"}, by_alias=True))
+                    )
+
+                # Create a section outline and add it to the list
+                sections.append(
+                    ArticleSectionOutline(
+                        **section.model_dump(exclude={"subsections"}, by_alias=True),
+                        subsections=subsections,
+                    )
+                )
+
+            # Create a chapter outline and add it to the list
+            chapters.append(
+                ArticleChapterOutline(
+                    **chapter.model_dump(exclude={"sections"}, by_alias=True),
+                    sections=sections,
+                )
+            )
+
+        # Create and return the article outline
+        return ArticleOutline(
+            **self.model_dump(exclude={"chapters"}, by_alias=True),
+            chapters=chapters,
+        )
+
     @classmethod
     def from_outline(cls, outline: ArticleOutline) -> "Article":
         """Generates an article from the given outline.
@@ -218,15 +267,18 @@ class Article(
         return article
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str) -> Self:
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Generates an article from the given Typst code."""
         return cls(
             chapters=[
                 ArticleChapter.from_typst_code(*pack) for pack in extract_sections(body, level=1, section_char="=")
             ],
             heading=title,
-            expected_word_count=word_count(body),
-            abstract="",
+            **fallback_kwargs(
+                kwargs,
+                expected_word_count=word_count(body),
+                abstract="",
+            ),
         )
 
     @classmethod
@@ -248,3 +300,4 @@ class Article(
 
         for a in self.iter_dfs():
             a.title = await text(f"Edit `{a.title}`.", default=a.title).ask_async() or a.title
+        return self

fabricatio/models/generic.py

@@ -122,7 +122,7 @@ class FromMapping(Base):
 
     @classmethod
     @abstractmethod
-    def from_mapping(cls, mapping: Mapping[str, Any], **kwargs: Any) -> List[Self]:
+    def from_mapping[S](cls: S, mapping: Mapping[str, Any], **kwargs: Any) -> List[S]:
         """Generate a list of objects from a mapping."""
 
 
@@ -186,7 +186,7 @@ class WithRef[T](Base):
     @overload
     def update_ref[S: WithRef](self: S, reference: None = None) -> S: ...
 
-    def update_ref[S: WithRef](self: S, reference: Union[T, "WithRef[T]", None] = None) -> S:  # noqa: PYI019
+    def update_ref[S: WithRef](self: S, reference: Union[T, "WithRef[T]", None] = None) -> S:
         """Update the reference of the object.
 
         Args:
@@ -201,7 +201,7 @@ class WithRef[T](Base):
             self._reference = reference  # pyright: ignore [reportAttributeAccessIssue]
         return self
 
-    def derive[S: WithRef](self: S, reference: Any) -> S:  # noqa: PYI019
+    def derive[S: WithRef](self: S, reference: Any) -> S:
         """Derive a new object from the current object.
 
         Args:
@@ -789,7 +789,7 @@ class ScopedConfig(Base):
     """The dimensions of the Milvus server."""
 
     @final
-    def fallback_to(self, other: "ScopedConfig") -> Self:
+    def fallback_to(self, other: Union["ScopedConfig", Any]) -> Self:
         """Merge configuration values with fallback priority.
 
         Copies non-null values from 'other' to self where current values are None.
@@ -800,6 +800,9 @@ class ScopedConfig(Base):
         Returns:
             Self: Current instance with merged values
         """
+        if not isinstance(other, ScopedConfig):
+            return self
+
         # Iterate over the attribute names and copy values from 'other' to 'self' where applicable
         # noinspection PydanticTypeChecker,PyTypeChecker
         for attr_name in ScopedConfig.model_fields:
@@ -811,7 +814,7 @@ class ScopedConfig(Base):
         return self
 
     @final
-    def hold_to(self, others: Union["ScopedConfig", Iterable["ScopedConfig"]]) -> Self:
+    def hold_to(self, others: Union[Union["ScopedConfig", Any], Iterable[Union["ScopedConfig", Any]]]) -> Self:
         """Propagate non-null values to other configurations.
 
         Copies current non-null values to target configurations where they are None.
@@ -824,7 +827,8 @@ class ScopedConfig(Base):
         """
         if not isinstance(others, Iterable):
             others = [others]
-        for other in others:
+
+        for other in (o for o in others if isinstance(o, ScopedConfig)):
             # noinspection PyTypeChecker,PydanticTypeChecker
             for attr_name in ScopedConfig.model_fields:
                 if (attr := getattr(self, attr_name)) is not None and getattr(other, attr_name) is None:

fabricatio/models/kwargs_types.py

@@ -33,7 +33,7 @@ class LLMKwargs(TypedDict, total=False):
     including generation parameters and caching options.
     """
 
-    model: str
+    model: Optional[str]
     temperature: float
     stop: str | list[str]
     top_p: float

fabricatio/models/role.py

@@ -2,18 +2,18 @@
 
 from typing import Any, Self, Set
 
-from fabricatio.capabilities.correct import Correct
-from fabricatio.capabilities.task import HandleTask, ProposeTask
+from fabricatio.capabilities.propose import Propose
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.action import WorkFlow
 from fabricatio.models.events import Event
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.tool import ToolBox
+from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field
 
 
-class Role(WithBriefing, ProposeTask, HandleTask, Correct):
+class Role(WithBriefing, Propose, ToolBoxUsage):
     """Class that represents a role with a registry of events and workflows.
 
     A Role serves as a container for workflows, managing their registration to events
@@ -23,7 +23,8 @@ class Role(WithBriefing, ProposeTask, HandleTask, Correct):
         registry: Mapping of events to workflows that handle them
         toolboxes: Set of toolboxes available to this role and its workflows
     """
-    description:str =""
+
+    description: str = ""
     """A brief description of the role's responsibilities and capabilities."""
 
     registry: dict[Event | str, WorkFlow] = Field(default_factory=dict)

fabricatio/rust.pyi

@@ -325,6 +325,16 @@ def convert_all_block_tex(string: str) -> str:
         The converted string with block TeX code replaced.
     """
 
+def fix_misplaced_labels(input: str) -> str:
+    """A func to fix labels in a string.
+
+    Args:
+        input: The input string containing misplaced labels.
+
+    Returns:
+        The fixed string with labels properly placed.
+    """
+
 def comment(string: str) -> str:
     """Add comment to the string.
 

fabricatio/utils.py

@@ -47,7 +47,7 @@ async def ask_retain[V](candidates: List[str], value_mapping: Optional[List[V]]
         "Please choose those that should be retained.",
         choices=[Choice(p, value=p, checked=True) for p in candidates]
         if value_mapping is None
-        else [Choice(p, value=v) for p, v in zip(candidates, value_mapping, strict=True)],
+        else [Choice(p, value=v, checked=True) for p, v in zip(candidates, value_mapping, strict=True)],
     ).ask_async()
 
 

{fabricatio-0.2.11.dev3.dist-info → fabricatio-0.2.12.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.11.dev3
+Version: 0.2.12.dev2
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.11.dev3.dist-info → fabricatio-0.2.12.dev2.dist-info}/RECORD

@@ -1,40 +1,41 @@
-fabricatio-0.2.11.dev3.dist-info/METADATA,sha256=alou2beIqeg3_FeS2dp-VQx15_Ep-0bf-tbGrUSxGmw,5263
-fabricatio-0.2.11.dev3.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
-fabricatio-0.2.11.dev3.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio-0.2.12.dev2.dist-info/METADATA,sha256=jqf6D_gMBaD9ClwWRHwr9-vI0WAFYc_u2XdLjpb4dq0,5263
+fabricatio-0.2.12.dev2.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
+fabricatio-0.2.12.dev2.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
 fabricatio/actions/article.py,sha256=SFl1zc0hz9vW2sW4VJm9-w8E7kLEty-2LzXi9wgWMmE,10905
-fabricatio/actions/article_rag.py,sha256=P1Bgvk6w8HogEMOw15-_cn2lzKpIcmfe_Ku2mlkdkYk,14318
+fabricatio/actions/article_rag.py,sha256=dJJfPkfwnx8P4BebESOpPaeTfvER-1U68aPXpwMdDCQ,18723
 fabricatio/actions/fs.py,sha256=gJR14U4ln35nt8Z7OWLVAZpqGaLnED-r1Yi-lX22tkI,959
-fabricatio/actions/output.py,sha256=ttXLC2wZmtVN9Ik8zsA7g45rwBO656LyRjOGRdVSyJA,6977
+fabricatio/actions/output.py,sha256=lX0HkDse3ypCzZgeF-8Dr-EnNFdBiE-WQ1iLPFlGM1g,8302
 fabricatio/actions/rag.py,sha256=KN-OWgcQjGmNgSZ-s5B8m4LpYKSGFJR8eq72mo2CP9k,3592
 fabricatio/actions/rules.py,sha256=dkvCgNDjt2KSO1VgPRsxT4YBmIIMeetZb5tiz-slYkU,3640
 fabricatio/actions/__init__.py,sha256=wVENCFtpVb1rLFxoOFJt9-8smLWXuJV7IwA8P3EfFz4,48
 fabricatio/capabilities/advanced_judge.py,sha256=selB0Gwf1F4gGJlwBiRo6gI4KOUROgh3WnzO3mZFEls,706
+fabricatio/capabilities/advanced_rag.py,sha256=0VbVqx2WGhQfF9LNkHM6tdeodNxF4S0Gh7_vmH3X0UA,2282
 fabricatio/capabilities/censor.py,sha256=bBT5qy-kp7fh8g4Lz3labSwxwJ60gGd_vrkc6k1cZ1U,4719
 fabricatio/capabilities/check.py,sha256=kYqzohhv2bZfl1aKSUt7a8snT8YEl2zgha_ZdAdMMfQ,8622
 fabricatio/capabilities/correct.py,sha256=W_cInqlciNEhyMK0YI53jk4EvW9uAdge90IO9OElUmA,10420
 fabricatio/capabilities/extract.py,sha256=PMjkWvbsv57IYT7zzd_xbIu4eQqQjpcmBtJzqlWZhHY,2495
 fabricatio/capabilities/propose.py,sha256=hkBeSlmcTdfYWT-ph6nlbtHXBozi_JXqXlWcnBy3W78,2007
-fabricatio/capabilities/rag.py,sha256=kqcunWBC6oA4P1rzIG2Xu9zqSg73H3uKPF41JJQ1HVI,9595
+fabricatio/capabilities/rag.py,sha256=a48dEaWE-sniwLhNtGz4xlSmRi_-PdOgDzNaDwnam_g,9619
 fabricatio/capabilities/rating.py,sha256=iMtQs3H6vCjuEjiuuz4SRKMVaX7yff7MHWz-slYvi5g,17835
 fabricatio/capabilities/review.py,sha256=-EMZe0ADFPT6fPGmra16UPjJC1M3rAs6dPFdTZ88Fgg,5060
 fabricatio/capabilities/task.py,sha256=uks1U-4LNCUdwdRxAbJJjMc31hOw6jlrcYriuQQfb04,4475
 fabricatio/capabilities/__init__.py,sha256=v1cHRHIJ2gxyqMLNCs6ERVcCakSasZNYzmMI4lqAcls,57
-fabricatio/config.py,sha256=okqrVoLhvmAjmfQXlLY3js4nC_qW4v7mxoYaGO2dMQ8,17984
+fabricatio/config.py,sha256=ckm55Oq0IhG1ztwHbKOG-7Mg7uWE1fb_-DxeKZyc8DQ,17951
 fabricatio/constants.py,sha256=thfDuF6JEtJ5CHOnAJLfqvn5834n8ep6DH2jc6XGzQM,577
 fabricatio/core.py,sha256=VQ_JKgUGIy2gZ8xsTBZCdr_IP7wC5aPg0_bsOmjQ588,6458
 fabricatio/decorators.py,sha256=RFMYUlQPf561-BIHetpMd7fPig5bZ2brzWiQTgoLOlY,8966
-fabricatio/fs/curd.py,sha256=p8y0LGKgVDk-CWOlm37E6wg7RK6RCD6denKo-VsW28c,4763
+fabricatio/fs/curd.py,sha256=652nHulbJ3gwt0Z3nywtPMmjhEyglDvEfc3p7ieJNNA,4777
 fabricatio/fs/readers.py,sha256=UXvcJO3UCsxHu9PPkg34Yh55Zi-miv61jD_wZQJgKRs,1751
 fabricatio/fs/__init__.py,sha256=FydmlEY_3QY74r1BpGDc5lFLhE6g6gkwOAtE30Fo-aI,786
 fabricatio/journal.py,sha256=stnEP88aUBA_GmU9gfTF2EZI8FS2OyMLGaMSTgK4QgA,476
-fabricatio/models/action.py,sha256=SnL8FAZsUCi9xM9BZT-CSjSRuI-4YBC5By8-ZHEBrW8,10109
+fabricatio/models/action.py,sha256=X7xbun7SyIEpC3-kbJgAagquJGkOBlxhBxbC_sHZX2w,10120
 fabricatio/models/adv_kwargs_types.py,sha256=kUO-SiZtFuz5cZCmMLnJJ9tjQ4-Zd_foo6R8HQMlM5A,1950
 fabricatio/models/events.py,sha256=wiirk_ASg3iXDOZU_gIimci1VZVzWE1nDmxy-hQVJ9M,4150
 fabricatio/models/extra/advanced_judge.py,sha256=INUl_41C8jkausDekkjnEmTwNfLCJ23TwFjq2cM23Cw,1092
-fabricatio/models/extra/aricle_rag.py,sha256=bJ9qNa9DkTVvja8GVue5wMnJCwnr6TEO7_fQbQK7fv4,9780
-fabricatio/models/extra/article_base.py,sha256=CeYs0D6XghxgpSnQ-rhtWuuFhcouy_vc6E5oUCPck_w,12840
+fabricatio/models/extra/aricle_rag.py,sha256=p91JI8FmFSrHVg5KbhJq4w8vQdx4VUW75SrtQUi9ju4,10987
+fabricatio/models/extra/article_base.py,sha256=eyawpikQEp0-PR32Z0atpRvA77Ht3KjDwL5RD---mf8,14066
 fabricatio/models/extra/article_essence.py,sha256=mlIkkRMR3I1RtqiiOnmIE3Vy623L4eECumkRzryE1pw,2749
-fabricatio/models/extra/article_main.py,sha256=4rjev0wpI2jf52NLNatRbqFQmN6rtKaMB9iy30hSEXM,9818
+fabricatio/models/extra/article_main.py,sha256=19ZXnVRk4oZA7t8wTJzSTCGiDUS8NTuy2uqcKCkqQqg,11907
 fabricatio/models/extra/article_outline.py,sha256=w7O0SHgC7exbptWVbR62FMHAueMgBpyWKVYMGGl_oj8,1427
 fabricatio/models/extra/article_proposal.py,sha256=NbyjW-7UiFPtnVD9nte75re4xL2pD4qL29PpNV4Cg_M,1870
 fabricatio/models/extra/patches.py,sha256=_WNCxtYzzsVfUxI16vu4IqsLahLYRHdbQN9er9tqhC0,997
@@ -42,24 +43,24 @@ fabricatio/models/extra/problem.py,sha256=8tTU-3giFHOi5j7NJsvH__JJyYcaGrcfsRnkzQ
 fabricatio/models/extra/rag.py,sha256=RMi8vhEPB0I5mVmjRLRLxYHUnm9pFhvVwysaIwmW2s0,3955
 fabricatio/models/extra/rule.py,sha256=KQQELVhCLUXhEZ35jU3WGYqKHuCYEAkn0p6pxAE-hOU,2625
 fabricatio/models/extra/__init__.py,sha256=XlYnS_2B9nhLhtQkjE7rvvfPmAAtXVdNi9bSDAR-Ge8,54
-fabricatio/models/generic.py,sha256=7wcG01DN9g4q1DJGZsTUxSTMixQgwXX0xlX4HbbLc6U,31185
-fabricatio/models/kwargs_types.py,sha256=GEw75ZiiDEFx_ImhCBENnPF7K0BcdTQ1ocH5jSPwMRs,4774
-fabricatio/models/role.py,sha256=-CRcj5_M3_ciLPzwiNn92grBmwoSLQ-n4koVZiCNTBM,2953
+fabricatio/models/generic.py,sha256=yXaVyUd3MK0lFUgsT0diMWtgD9s5rM9yKTH44eE58jM,31314
+fabricatio/models/kwargs_types.py,sha256=BPqZUgxz4WJaB7hmvrhNxHXp-O7O4SiAdn6UguBRij8,4784
+fabricatio/models/role.py,sha256=b8FDRF4VjMMt93Uh5yiAufFbsoH7RcUaaFJAjVmq2l0,2931
 fabricatio/models/task.py,sha256=bLYSKjlRAlb4jMYyF12RTnm_8pVXysSmX8CYLrEmbQ8,11096
 fabricatio/models/tool.py,sha256=jQ51g4lwTPfsMF1nbreDJtBczbxIHoXcPuLSOqHliq8,12506
 fabricatio/models/usages.py,sha256=0bzITf0vug9ZaN6qnjNfFB7T8BAvpXE0bvx0otFYLLA,33356
 fabricatio/parser.py,sha256=-RbW2yzfJiu2ARq-lZw4tfgsjY2rIZWtJpoUmaE6gJQ,6637
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fabricatio/rust.pyi,sha256=GJRLeeQ1UIaf5kOgJWX2GkwIacoTBk3yBKuD5cKW8i4,10489
+fabricatio/rust.pyi,sha256=Tdyid-kS402bxiIdX218nh2ekkGBD66K-6PhMN-xU0k,10734
 fabricatio/rust_instances.py,sha256=Byeo8KHW_dJiXujJq7YPGDLBX5bHNDYbBc4sY3uubVY,313
 fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
 fabricatio/toolboxes/fs.py,sha256=l4L1CVxJmjw9Ld2XUpIlWfV0_Fu_2Og6d3E13I-S4aE,736
 fabricatio/toolboxes/__init__.py,sha256=KBJi5OG_pExscdlM7Bnt_UF43j4I3Lv6G71kPVu4KQU,395
-fabricatio/utils.py,sha256=sLD6L_BHXusJjCu3gsUpxOFbmEOnT577xU1kaZQ04SE,3084
+fabricatio/utils.py,sha256=4aK6bNHCCGEbSkLRKrDBzabuVAow9PrJ6SVGUX1Rt-U,3098
 fabricatio/workflows/articles.py,sha256=ObYTFUqLUk_CzdmmnX6S7APfxcGmPFqnFr9pdjU7Z4Y,969
 fabricatio/workflows/rag.py,sha256=-YYp2tlE9Vtfgpg6ROpu6QVO8j8yVSPa6yDzlN3qVxs,520
 fabricatio/workflows/__init__.py,sha256=5ScFSTA-bvhCesj3U9Mnmi6Law6N1fmh5UKyh58L3u8,51
 fabricatio/__init__.py,sha256=Rmvq2VgdS2u68vnOi2i5RbeWbAwrJDbk8D8D883PJWE,1022
-fabricatio/rust.cp312-win_amd64.pyd,sha256=Z3wuzfa_m81nq1W6MVF66ne-gQ0-gkNFdknay_wVskY,4150272
-fabricatio-0.2.11.dev3.data/scripts/tdown.exe,sha256=nHWlrICGMzmDpo1bZA-l1tqyCZhSreyrc5S1J3E7KgU,3350016
-fabricatio-0.2.11.dev3.dist-info/RECORD,,
+fabricatio/rust.cp312-win_amd64.pyd,sha256=ym9nuMyb-fdV1XDY4sHtPfzU8o7ee0r5U1LhAnTtLOA,4161536
+fabricatio-0.2.12.dev2.data/scripts/tdown.exe,sha256=PUdB1PvJP6qyimU9c8qNzl9PcQtR1eBJxTtnLiY4wuk,3349504
+fabricatio-0.2.12.dev2.dist-info/RECORD,,