fabricatio 0.2.11.dev3__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.12.dev1__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/actions/article_rag.py

@@ -4,6 +4,8 @@ from asyncio import gather
 from pathlib import Path
 from typing import List, Optional
 
+from pydantic import PositiveInt
+
 from fabricatio import BibManager
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.extract import Extract
@@ -18,13 +20,35 @@ from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.rule import RuleSet
 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"
+    "Wrapp inline expression using $ $,like '$>5m$' '$89%$' , and wrapp block equation using $$ $$. if you are using '$' as the money unit, you should add a '\\' before it to avoid being interpreted as a inline equation. For example 'The pants worths 5\\$.'\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 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\n"
+    "In @eqt:mass-energy-equation , $m$ stands for mass, $c$ stands for speed of light, and $E$ stands for energy. \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
     """The model to use for extracting the content from the retrieved references."""
@@ -32,43 +56,24 @@ class WriteArticleContentRAG(Action, RAG, Extract):
     """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 +97,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 +133,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,6 +154,7 @@ 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",
+                model=self.extractor_model,
             ),
             "Failed to propose new subsection.",
         )
@@ -162,12 +178,15 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         return (
             (
                 await self.aask(
-                    f"{cm.as_prompt()}\nAbove is some related reference retrieved for you."
+                    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}"
+                    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."
                 )
             )
             .replace(r" \( ", "$")
@@ -175,7 +194,9 @@ class WriteArticleContentRAG(Action, RAG, Extract):
             .replace(r"\(", "$")
             .replace(r"\)", "$")
             .replace("\\[\n", "$$\n")
+            .replace("\\[ ", "$$\n")
             .replace("\n\\]", "\n$$")
+            .replace(" \\]", "\n$$")
         )
 
     async def search_database(
@@ -185,28 +206,113 @@ 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",
+                search_req,
                 model=self.query_model,
             ),
             "Failed to refine query.",
         )
 
+        if supervisor:
+            ref_q = await ask_retain(ref_q)
+        ret = await self.aretrieve(
+            ref_q,
+            ArticleChunk,
+            final_limit=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}",
+            model=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,
+            final_limit=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, RAG):
+    """Write an article based on the provided outline."""
+
+    output_key: str = "consult_count"
+
+    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: Optional[str] = None
+    """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
+
+        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()
+            ref_q = await self.arefined_query(req, model=self.ref_q_model)
+            refs = await self.aretrieve(
+                ok(ref_q, "Failed to refine query."),
+                ArticleChunk,
+                final_limit=self.ref_limit,
+                result_per_query=self.ref_per_q,
+                similarity_threshold=self.similarity_threshold,
+            )
+
+            ret = await self.aask(f"{cm.add_chunks(refs).as_prompt()}\n{self.req}\n{req}")
+            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):

fabricatio/actions/output.py

@@ -1,16 +1,18 @@
 """Dump the finalized output to a file."""
 
 from pathlib import Path
-from typing import Any, Iterable, List, Mapping, Optional, Type
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Type
 
+from fabricatio import TEMPLATE_MANAGER
 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 +40,37 @@ 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: Dict[str, Any],
+        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()}")
+        return TEMPLATE_MANAGER.render_template(self.template_name, to_dump)
+
+
+class PersistentAll(Action, LLMUsage):
     """Persist all the data to a file."""
 
     output_key: str = "persistent_count"

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(self) -> Self:
+        """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_sec_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.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:
@@ -181,6 +185,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 +266,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 +299,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/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.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.11.dev3
+Version: 0.2.12.dev1
 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.dev1.dist-info}/RECORD

@@ -1,46 +1,46 @@
-fabricatio-0.2.11.dev3.dist-info/METADATA,sha256=xdi73tDlxylje7XHzZ0RtsCrEJ4biCZm06ML_qDR3EQ,5120
-fabricatio-0.2.11.dev3.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
-fabricatio-0.2.11.dev3.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
+fabricatio-0.2.12.dev1.dist-info/METADATA,sha256=qjBv5RTwJvd0KEFkb-OpKBorNX43NNrWf-3l5mhWOuk,5120
+fabricatio-0.2.12.dev1.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
+fabricatio-0.2.12.dev1.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
 fabricatio/decorators.py,sha256=iuFCTtZ4VXwxJpM_z-CtrEpTaVZsv_eBFe5mOhe4wlo,8715
 fabricatio/constants.py,sha256=JxtaKGTf0IQhM-MNCHtr6x85Ejg8FWYcie-Z_RupCBg,557
 fabricatio/core.py,sha256=MaEKZ6DDmbdScAY-7F1gwGA6fr7ADX6Mz5rNVi2msFA,6277
-fabricatio/models/generic.py,sha256=lEMpFCo-kNL1OGWvtqE3DlI1KQyoShdI5YW-niiwNos,30267
+fabricatio/models/generic.py,sha256=a22CjQSlu-0WDdDVQiCIOddylaMFnv9lMLVuIeNKV1w,30392
 fabricatio/models/tool.py,sha256=VM3rMeDpUbeeFAKpsPfweJ2JGHf-w5f1voDnuhK99ew,12178
-fabricatio/models/role.py,sha256=iao4teYzY5QjfN1B2tEY5wbQq5afFz7jdhi6IziIong,2878
-fabricatio/models/kwargs_types.py,sha256=MI-P6_ZiCGzlyjwLNlMhHJbKb6fxXl_fBVHvPzDne1M,4608
+fabricatio/models/role.py,sha256=5SJ1Vm6H3FwOVEk5Z-4GBJWABI3OKAKwkz5t170osi8,2855
+fabricatio/models/kwargs_types.py,sha256=aI844DNQXLbSBC3P0bZQLJpuJxwwF66WTDbbYQTftaE,4618
 fabricatio/models/extra/article_proposal.py,sha256=4G2qLkMxtK54G1ANgPW0G3w4Pahxgk2lhGPU5KMxuzw,1818
 fabricatio/models/extra/advanced_judge.py,sha256=CKPP4Lseb_Ey8Y7i2V9HJfB-mZgCknFdqq7Zo41o6s4,1060
-fabricatio/models/extra/article_main.py,sha256=-8BlihRkBwIyhD5gA86w212ki7hxLElTFW7x-81WwHU,9568
+fabricatio/models/extra/article_main.py,sha256=kPa_y5j9eMOW7zfQn779On31CS2ckqZtnSFxOhkpGD8,11522
 fabricatio/models/extra/problem.py,sha256=1Sd8hsThQK6pXMXhErRhP1ft58z4PvqeB8AV8VcXiaI,7051
 fabricatio/models/extra/article_essence.py,sha256=zUfZ2_bX3h__RaVPwJlxQ-tkFyfSV8SdX8DsmFX6v_w,2649
 fabricatio/models/extra/rag.py,sha256=RWv_YJhDX6UL4t3sRtQt-LYMtxN-K-t931nmyiJXkKM,3857
 fabricatio/models/extra/article_outline.py,sha256=2vqMDhXwfRooHEe_cblkOj-4V96VsIAy68x22KBEQPQ,1387
 fabricatio/models/extra/__init__.py,sha256=0R9eZsCNu6OV-Xtf15H7FrqhfHTFBFf3fBrcd7ChsJ0,53
 fabricatio/models/extra/rule.py,sha256=b756_XmWeDoJ1qOFEGy6ZfP8O7rBjOZs4XvfZvWKXXI,2574
-fabricatio/models/extra/aricle_rag.py,sha256=2y9XBgCwi_9ZyMYEF2i3eKZO4oYEj4YgGtRdN9AS_p0,9538
-fabricatio/models/extra/article_base.py,sha256=K15Nw98DgLWZs-8CFrgJqE2r1GgpzFIuF_ftRHbB7yE,12516
+fabricatio/models/extra/aricle_rag.py,sha256=-w1fxs5PrsLTYPmNtUhWSeucQ9evnasUB75aMlzutL0,10722
+fabricatio/models/extra/article_base.py,sha256=QIcQbsp4-nE6OVpV82jLw1Ki1cXwvsQJVJns6sVhy14,13708
 fabricatio/models/extra/patches.py,sha256=_ghmnlvTZQq7UJyaH77mTZE9abjvxRJ2mgWHUbezUls,977
 fabricatio/models/adv_kwargs_types.py,sha256=659KMMuvdVq1xJxavLbUAMWxPOAz0RP9bNaZm3hyz-4,1890
 fabricatio/models/usages.py,sha256=FVRhh_AulXlJF9uUmJzKEdiLz-di0rAiaQm4snYEid0,32571
 fabricatio/models/events.py,sha256=-9Xy8kcZug1tYwxmt3GpXtCkNfZUMSFvAH5HdZoRJTI,4030
 fabricatio/models/task.py,sha256=O4v5T3HuzYblGeeqNzTDOCbulhGovR6olV2ojD0FJvk,10785
-fabricatio/models/action.py,sha256=JPLp7VjX09FjaTxSeda4Zsywb1XU2lvdvPcWY70DtzQ,9841
+fabricatio/models/action.py,sha256=oOyxkhocfWDetfz9EEvAyDU1U3w0X1OrzdtwNHTxDr8,9854
 fabricatio/toolboxes/fs.py,sha256=OQMdeokYxSNVrCZJAweJ0cYiK4k2QuEiNdIbS5IHIV8,705
 fabricatio/toolboxes/__init__.py,sha256=dYm_Gd8XolSU_h4wnkA09dlaLDK146eeFz0CUgPZ8_c,380
 fabricatio/toolboxes/arithmetic.py,sha256=sSTPkKI6-mb278DwQKFO9jKyzc9kCx45xNH7V6bGBpE,1307
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fabricatio/fs/readers.py,sha256=hFHfGw1E58Da0ndBXXWcD2t-4HNdR1FimeDxuMI4-oE,1690
-fabricatio/fs/curd.py,sha256=QqwnyLdVALNnerYGXf6a0irqoPSNE9_GJV9bJ33kbl0,4610
+fabricatio/fs/curd.py,sha256=x7Je9V1ydv-BdZTjlLc3syZ6380gkOhpfrfnhXstisg,4624
 fabricatio/fs/__init__.py,sha256=abIYGDiX5bZ9vSHfro1-OtogzD_3vuR71FZMvZt8820,750
 fabricatio/rust_instances.py,sha256=i5fIt6XkE8UwUU4JarmPt50AZs8aJW6efaypSLGLl0I,303
-fabricatio/config.py,sha256=NbZu1AnHzR2VFOvzuBP5TSb9Jo3k17ODVuhL1jmT4-c,17559
-fabricatio/utils.py,sha256=BbH69s0TaJgy2idq5-5WEO5jgny1jQy7piG7B4YPuWc,2990
+fabricatio/config.py,sha256=Zc2UG1Jf8u0XfwHR7yrApgynzdX_uC6jInMw8PDm64o,17526
+fabricatio/utils.py,sha256=DZDOsJN1FxTVqq-i1fAJZdLfDYxyVoMAJFQURuYt1rY,3004
 fabricatio/journal.py,sha256=Op0wC-JlZumnAc_aDmYM4ljnSNLoKEEMfcIRbCF69ow,455
 fabricatio/rust.pyi,sha256=EEZTQquqkHZ1G29YUPICwb9SJBzKgCB1B0ILuFNUoR0,10143
 fabricatio/__init__.py,sha256=OXoMMHJKHEB_vN97_34U4I5QpAKL9xnVQEVcBCvwBCg,986
 fabricatio/actions/fs.py,sha256=nlTmk-tYDW158nz_fzlsNfuYJwj7j4BHn_MFY5hxdqs,934
-fabricatio/actions/output.py,sha256=XudogHKTp-9qqB7fvqRRjtcKee3I-vZ0WepMeEE7qsI,6805
-fabricatio/actions/article_rag.py,sha256=gHRkrR9OaNEu71gJF3YsUt3c5Tr0y5e946xzoxOuNRk,13992
+fabricatio/actions/output.py,sha256=KR9SKDxLSp6rRWf0sriSGwITwe2HE506QGUP3yj-N4E,7891
+fabricatio/actions/article_rag.py,sha256=uGnHfw7fNzxHPXNB7ukXe9gfZaBrHtJRA54BVTnZVIc,18506
 fabricatio/actions/rag.py,sha256=-bA7KkZEFfWEanAPHzYwRHG7zRlTZcNDI7HL3n-lDuE,3496
 fabricatio/actions/__init__.py,sha256=ZMa1LeM5BNeqp-J-D32W-f5bD53-kdXGyt0zuueJofM,47
 fabricatio/actions/article.py,sha256=syUjEyKppdT72Xd1LSXKR3Djo1aybRPeFRHRzifNhm0,10632
@@ -60,6 +60,6 @@ fabricatio/capabilities/review.py,sha256=EPL8IlxSKO0XStBkXdW7FJMbPztDQMv9w7tHgu6
 fabricatio/capabilities/propose.py,sha256=vOJvmmnMBHUQB6N1AmZNFw42jf7Bl2mBRNlBK15TpNI,1942
 fabricatio/capabilities/task.py,sha256=_BAQonNy5JH3JxhLmPGfn0nDvn_ENKXyOdql8EVXRLE,4362
 fabricatio/capabilities/extract.py,sha256=b4_Tuc9O6Pe71y4Tj-JHMb4simdhduVR-rcfD9yW8RA,2425
-fabricatio/rust.cpython-312-x86_64-linux-gnu.so,sha256=RMc1j9N5smoAD9ffKxSFOinOa3O2p7UlIf4y4n9F7lM,4435800
-fabricatio-0.2.11.dev3.data/scripts/tdown,sha256=bb3sOe5zM95YbGfmmxLTz4ZK3o-SFFAJ6Mdu6clF5Q8,4585440
-fabricatio-0.2.11.dev3.dist-info/RECORD,,
+fabricatio/rust.cpython-312-x86_64-linux-gnu.so,sha256=ABhIKEaDhWIR9Bx9rY2CqpwvJNBsxdXb1DDYQhbnhvI,4438896
+fabricatio-0.2.12.dev1.data/scripts/tdown,sha256=EEtn-cmxQQ9M1XIunkzQFqqGRRfo6WQXlk3mv7oFARw,4582192
+fabricatio-0.2.12.dev1.dist-info/RECORD,,