fabricatio 0.2.11.dev0__cp312-cp312-win_amd64.whl → 0.2.11.dev2__cp312-cp312-win_amd64.whl

fabricatio/actions/article.py

@@ -5,8 +5,11 @@ from pathlib import Path
 from typing import Callable, List, Optional
 
 from more_itertools import filter_map
+from pydantic import Field
+from rich import print as r_print
 
 from fabricatio.capabilities.censor import Censor
+from fabricatio.capabilities.extract import Extract
 from fabricatio.capabilities.propose import Propose
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
@@ -16,9 +19,10 @@ from fabricatio.models.extra.article_main import Article
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.extra.rule import RuleSet
+from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.rust import BibManager, detect_language
-from fabricatio.utils import ok
+from fabricatio.utils import ok, wrapp_in_block
 
 
 class ExtractArticleEssence(Action, Propose):
@@ -130,30 +134,45 @@ class GenerateArticleProposal(Action, Propose):
         ).update_ref(briefing)
 
 
-class GenerateInitialOutline(Action, Propose):
+class GenerateInitialOutline(Action, Extract):
     """Generate the initial article outline based on the article proposal."""
 
     output_key: str = "initial_article_outline"
     """The key of the output data."""
 
+    supervisor: bool = False
+    """Whether to use the supervisor to fix the outline."""
+
+    extract_kwargs: ValidateKwargs[Optional[ArticleOutline]] = Field(default_factory=ValidateKwargs)
+    """The kwargs to extract the outline."""
+
     async def _execute(
         self,
         article_proposal: ArticleProposal,
         **_,
     ) -> Optional[ArticleOutline]:
         raw_outline = await self.aask(
-            f"{(article_proposal.as_prompt())}\n\nNote that you should use `{article_proposal.language}` to write the `ArticleOutline`\n"
+            f"{(article_proposal.as_prompt())}\n"
             f"Design each chapter of a proper and academic and ready for release manner.\n"
             f"You Must make sure every chapter have sections, and every section have subsections.\n"
             f"Make the chapter and sections and subsections bing divided into a specific enough article component.\n"
-            f"Every chapter must have sections, every section must have subsections.",
+            f"Every chapter must have sections, every section must have subsections.\n"
+            f"Note that you SHALL use `{article_proposal.language}` as written language",
         )
 
+        if self.supervisor:
+            from questionary import confirm, text
+
+            r_print(raw_outline)
+            while not await confirm("Accept this version and continue?", default=True).ask_async():
+                imp = await text("Enter the improvement:").ask_async()
+                raw_outline = await self.aask(
+                    f"{article_proposal.as_prompt()}\n{wrapp_in_block(raw_outline, 'Previous ArticleOutline')}\n{imp}"
+                )
+                r_print(raw_outline)
+
         return ok(
-            await self.propose(
-                ArticleOutline,
-                f"{raw_outline}\n\n\n\noutline provided above is the outline i need to extract to a JSON,",
-            ),
+            await self.extract(ArticleOutline, raw_outline, **self.extract_kwargs),
             "Could not generate the initial outline.",
         ).update_ref(article_proposal)
 

fabricatio/actions/article_rag.py

@@ -6,8 +6,9 @@ from typing import List, Optional
 
 from fabricatio import BibManager
 from fabricatio.capabilities.censor import Censor
-from fabricatio.capabilities.propose import Propose
+from fabricatio.capabilities.extract import Extract
 from fabricatio.capabilities.rag import RAG
+from fabricatio.decorators import precheck_package
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra.aricle_rag import ArticleChunk, CitationManager
@@ -15,18 +16,42 @@ 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.utils import ok
+from fabricatio.utils import ask_retain, ok
 
 
-class WriteArticleContentRAG(Action, RAG, Propose):
+class WriteArticleContentRAG(Action, RAG, Extract):
     """Write an article based on the provided outline."""
 
-    ref_limit: int = 100
+    ref_limit: int = 35
     """The limit of references to be retrieved"""
+    threshold: float = 0.55
+    """The threshold of relevance"""
     extractor_model: str
     """The model to use for extracting the content from the retrieved references."""
     query_model: str
     """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"
+        "```"
+    )
 
     async def _execute(
         self,
@@ -36,14 +61,57 @@ class WriteArticleContentRAG(Action, RAG, Propose):
         **cxt,
     ) -> Article:
         article = Article.from_outline(article_outline).update_ref(article_outline)
-        await gather(
-            *[
-                self._inner(article, article_outline, chap, sec, subsec)
-                for chap, sec, subsec in article.iter_subsections()
-            ]
-        )
+
+        if self.supervisor:
+            await gather(
+                *[
+                    self._supervisor_inner(article, article_outline, chap, sec, subsec)
+                    for chap, sec, subsec in article.iter_subsections()
+                ]
+            )
+        else:
+            await gather(
+                *[
+                    self._inner(article, article_outline, chap, sec, subsec)
+                    for chap, sec, subsec in article.iter_subsections()
+                ]
+            )
         return article.convert_tex()
 
+    @precheck_package(
+        "questionary", "`questionary` is required for supervisor mode, please install it by `fabricatio[qa]`"
+    )
+    async def _supervisor_inner(
+        self,
+        article: Article,
+        article_outline: ArticleOutline,
+        chap: ArticleChapter,
+        sec: ArticleSection,
+        subsec: ArticleSubsection,
+    ) -> ArticleSubsection:
+        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()
+
+        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)
+                cm.add_chunks(await ask_retain([r.chunk for r in new_refs], new_refs))
+
+            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
+
+            r_print(raw)
+
+        return await self.extract_new_subsec(subsec, raw, cm)
+
     async def _inner(
         self,
         article: Article,
@@ -52,62 +120,92 @@ class WriteArticleContentRAG(Action, RAG, Propose):
         sec: ArticleSection,
         subsec: ArticleSubsection,
     ) -> ArticleSubsection:
-        ref_q = ok(
-            await self.arefined_query(
-                f"{article_outline.display()}\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"plus, you can search required formulas by using latex equation code.\n"
-                f"provide 10 queries as possible, to get best result!\n"
-                f"You should provide both English version and chinese version of the refined queries!\n",
-                model=self.query_model,
-            ),
-            "Failed to refine query.",
-        )
-        ret = await self.aretrieve(ref_q, ArticleChunk, final_limit=self.ref_limit, result_per_query=25)
-        ret.reverse()
-        cm = CitationManager().update_chunks(ret)
-
-        raw_paras = await self.aask(
-            f"{cm.as_prompt()}\nAbove is some related reference retrieved for you. When need to cite some of them ,you MUST follow the academic convention,"
-            f"{article.referenced.display()}\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"You can output the written paragraphs directly, without explanation. you should use `{subsec.language}`, and maintain academic writing style."
-            f"In addition,you MUST follow the academic convention and use [[1]] to cite the first reference, and use [[9]] to cite the second reference, and so on.\n"
-            f"It 's greatly recommended to cite multiple references that stands for the same opinion at a single sentences, like [[1,5,9]] for 1th,5th and 9th references,[[1-9,16]] for 1th to 9th and 16th references.\n"
-            f"citation number is REQUIRED to cite any reference!\n"
-            f"for paragraphs that need write equation you should also no forget to doing so. wrapp inline equation using $ $, and wrapp block equation using $$ $$.\n"
-        )
+        ret = await self.search_database(article, article_outline, chap, sec, subsec)
+        cm = CitationManager(article_chunks=ret).set_cite_number_all()
 
-        raw_paras = (
-            raw_paras.replace(r" \( ", "$").replace(r" \) ", "$").replace("\\[\n", "$$\n").replace("\n\\]", "\n$$")
-        )
+        raw_paras = await self.write_raw(article, article_outline, chap, sec, subsec, cm)
 
+        return await self.extract_new_subsec(subsec, raw_paras, cm)
+
+    async def extract_new_subsec(
+        self, subsec: ArticleSubsection, raw_paras: str, cm: CitationManager
+    ) -> ArticleSubsection:
+        """Extract the new subsec."""
         new_subsec = ok(
-            await self.propose(
+            await self.extract(
                 ArticleSubsection,
-                f"{raw_paras}\nAbove is the subsection titled `{subsec.title}`.\n"
-                f"I need you to extract the content to update my subsection obj provided below.\n"
-                f"Everything is build upon the typst language, which is similar to latex, \n"
-                f"so reference annotation like `[[1]]` for 1th reference or `[[2,6]]` for 2th and 6th reference or "
-                f"`[[1,5,9]]` for 1th,5th and 9th references or "
-                f"`[[1-9,16]]` for 1th to 9th and 16th references\n"
-                f"Those reference mark shall not be omitted during the extraction\n"
-                f"Wrapp inline expression using $ $, and wrapp block equation using $$ $$\n\n\n"
-                f"{subsec.display()}",
-                model=self.extractor_model,
+                raw_paras,
+                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",
             ),
             "Failed to propose new subsection.",
         )
-
         for p in new_subsec.paragraphs:
-            p.content = cm.apply(p.content)
-
+            p.content = cm.apply(p.content).replace("$$", "\n$$\n")
         subsec.update_from(new_subsec)
         logger.debug(f"{subsec.title}:rpl\n{subsec.display()}")
         return subsec
 
+    async def write_raw(
+        self,
+        article: Article,
+        article_outline: ArticleOutline,
+        chap: ArticleChapter,
+        sec: ArticleSection,
+        subsec: ArticleSubsection,
+        cm: CitationManager,
+        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$$")
+        )
+
+    async def search_database(
+        self,
+        article: Article,
+        article_outline: ArticleOutline,
+        chap: ArticleChapter,
+        sec: ArticleSection,
+        subsec: ArticleSubsection,
+        extra_instruction: str = "",
+    ) -> List[ArticleChunk]:
+        """Search database for related references."""
+        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,
+            ),
+            "Failed to refine query.",
+        )
+
+        if self.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
+        )
+
 
 class TweakArticleRAG(Action, RAG, Censor):
     """Write an article based on the provided outline.

fabricatio/capabilities/extract.py

@@ -18,6 +18,7 @@ class Extract(Propose):
         cls: Type[M],
         source: str,
         extract_requirement: Optional[str] = None,
+        align_language: bool = True,
         **kwargs: Unpack[ValidateKwargs[M]],
     ) -> M: ...
     @overload
@@ -26,6 +27,7 @@ class Extract(Propose):
         cls: Type[M],
         source: str,
         extract_requirement: Optional[str] = None,
+        align_language: bool = True,
         **kwargs: Unpack[ValidateKwargs[None]],
     ) -> Optional[M]: ...
 
@@ -35,6 +37,7 @@ class Extract(Propose):
         cls: Type[M],
         source: List[str],
         extract_requirement: Optional[str] = None,
+        align_language: bool = True,
         **kwargs: Unpack[ValidateKwargs[M]],
     ) -> List[M]: ...
     @overload
@@ -43,6 +46,7 @@ class Extract(Propose):
         cls: Type[M],
         source: List[str],
         extract_requirement: Optional[str] = None,
+        align_language: bool = True,
         **kwargs: Unpack[ValidateKwargs[None]],
     ) -> List[Optional[M]]: ...
     async def extract[M: ProposedAble](
@@ -50,6 +54,7 @@ class Extract(Propose):
         cls: Type[M],
         source: List[str] | str,
         extract_requirement: Optional[str] = None,
+        align_language: bool = True,
         **kwargs: Unpack[ValidateKwargs[Optional[M]]],
     ) -> M | List[M] | Optional[M] | List[Optional[M]]:
         """Extract information from a given source to a model."""
@@ -59,7 +64,7 @@ class Extract(Propose):
                 configs.templates.extract_template,
                 [{"source": s, "extract_requirement": extract_requirement} for s in source]
                 if isinstance(source, list)
-                else {"source": source, "extract_requirement": extract_requirement},
+                else {"source": source, "extract_requirement": extract_requirement, "align_language": align_language},
             ),
             **kwargs,
         )

fabricatio/config.py

@@ -255,7 +255,7 @@ class TemplateConfig(BaseModel):
 
     extract_template: str = Field(default="extract")
     """The name of the extract template which will be used to extract model from string."""
-    
+
 class MagikaConfig(BaseModel):
     """Magika configuration class."""
 

fabricatio/decorators.py

@@ -6,7 +6,7 @@ from importlib.util import find_spec
 from inspect import signature
 from shutil import which
 from types import ModuleType
-from typing import Callable, List, Optional
+from typing import Callable, Coroutine, List, Optional
 
 from fabricatio.config import configs
 from fabricatio.journal import logger
@@ -23,7 +23,20 @@ def precheck_package[**P, R](package_name: str, msg: str) -> Callable[[Callable[
         bool: True if the package exists, False otherwise.
     """
 
-    def _wrapper(func: Callable[P, R]) -> Callable[P, R]:
+    def _wrapper(
+        func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
+    ) -> Callable[P, R] | Callable[P, Coroutine[None, None, R]]:
+        if iscoroutinefunction(func):
+
+            @wraps(func)
+            async def _async_inner(*args: P.args, **kwargs: P.kwargs) -> R:
+                if find_spec(package_name):
+                    return await func(*args, **kwargs)
+                raise RuntimeError(msg)
+
+            return _async_inner
+
+        @wraps(func)
         def _inner(*args: P.args, **kwargs: P.kwargs) -> R:
             if find_spec(package_name):
                 return func(*args, **kwargs)
@@ -35,7 +48,7 @@ def precheck_package[**P, R](package_name: str, msg: str) -> Callable[[Callable[
 
 
 def depend_on_external_cmd[**P, R](
-        bin_name: str, install_tip: Optional[str], homepage: Optional[str] = None
+    bin_name: str, install_tip: Optional[str], homepage: Optional[str] = None
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     """Decorator to check for the presence of an external command.
 
@@ -88,8 +101,9 @@ def logging_execution_info[**P, R](func: Callable[P, R]) -> Callable[P, R]:
     return _wrapper
 
 
-@precheck_package("questionary",
-                  "'questionary' is required to run this function. Have you installed `fabricatio[qa]`?.")
+@precheck_package(
+    "questionary", "'questionary' is required to run this function. Have you installed `fabricatio[qa]`?."
+)
 def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]] | Callable[P, R]:
     """Decorator to confirm before executing a function.
 
@@ -109,8 +123,8 @@ def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]]
         @wraps(func)
         async def _wrapper(*args: P.args, **kwargs: P.kwargs) -> Optional[R]:
             if await confirm(
-                    f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n🔑 Kwargs:{kwargs}\n",
-                    instruction="Please input [Yes/No] to proceed (default: Yes):",
+                f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n🔑 Kwargs:{kwargs}\n",
+                instruction="Please input [Yes/No] to proceed (default: Yes):",
             ).ask_async():
                 return await func(*args, **kwargs)
             logger.warning(f"Function: {func.__name__}{signature(func)} canceled by user.")
@@ -121,8 +135,8 @@ def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]]
         @wraps(func)
         def _wrapper(*args: P.args, **kwargs: P.kwargs) -> Optional[R]:
             if confirm(
-                    f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n��� Kwargs:{kwargs}\n",
-                    instruction="Please input [Yes/No] to proceed (default: Yes):",
+                f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n��� Kwargs:{kwargs}\n",
+                instruction="Please input [Yes/No] to proceed (default: Yes):",
             ).ask():
                 return func(*args, **kwargs)
             logger.warning(f"Function: {func.__name__}{signature(func)} canceled by user.")
@@ -203,7 +217,9 @@ def use_temp_module[**P, R](modules: ModuleType | List[ModuleType]) -> Callable[
     return _decorator
 
 
-def logging_exec_time[**P, R](func: Callable[P, R]) -> Callable[P, R]:
+def logging_exec_time[**P, R](
+    func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
+) -> Callable[P, R] | Callable[P, Coroutine[None, None, R]]:
     """Decorator to log the execution time of a function.
 
     Args:
@@ -215,6 +231,7 @@ def logging_exec_time[**P, R](func: Callable[P, R]) -> Callable[P, R]:
     from time import time
 
     if iscoroutinefunction(func):
+
         @wraps(func)
         async def _async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             start_time = time()

fabricatio/models/extra/aricle_rag.py

@@ -136,7 +136,7 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
         """Purge numeric citation."""
         import re
 
-        return re.sub(r"\[[\d\s,\\~–-]+]", "", string)  # noqa: RUF001
+        return re.sub(r"\[[\d\s,\\~–-]+]", "", string)
 
     @property
     def auther_firstnames(self) -> List[str]:
@@ -175,7 +175,7 @@ class CitationManager(AsPrompt):
     article_chunks: List[ArticleChunk] = Field(default_factory=list)
     """Article chunks."""
 
-    pat: str = r"\[\[([\d\s,-]*)]]"
+    pat: str = r"(\[\[([\d\s,-]*)]])"
     """Regex pattern to match citations."""
     sep: str = ","
     """Separator for citation numbers."""
@@ -190,6 +190,12 @@ class CitationManager(AsPrompt):
             self.set_cite_number_all()
         return self
 
+    def add_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True)-> Self:
+        """Add article chunks."""
+        self.article_chunks.extend(article_chunks)
+        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):
@@ -202,14 +208,15 @@ class CitationManager(AsPrompt):
 
     def apply(self, string: str) -> str:
         """Apply citation replacements to the input string."""
-        matches = re.findall(self.pat, string)
-
-        for m in matches:
+        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}")
             citation_number_seq = list(flatten(self.decode_expr(n) for n in notations))
+            logger.info(f"Citation Number Sequence: {citation_number_seq}")
             dedup = self.deduplicate_citation(citation_number_seq)
-            string.replace(m, self.unpack_cite_seq(dedup))
+            logger.info(f"Deduplicated Citation Number Sequence: {dedup}")
+            string=string.replace(origin, self.unpack_cite_seq(dedup))
         return string
 
     def decode_expr(self, string: str) -> List[int]:
@@ -226,7 +233,7 @@ class CitationManager(AsPrompt):
     def deduplicate_citation(self, citation_seq: List[int]) -> List[int]:
         """Deduplicate citation sequence."""
         chunk_seq = [a for a in self.article_chunks if a.cite_number in citation_seq]
-        deduped = unique(chunk_seq, lambda a: a.cite_number)
+        deduped = unique(chunk_seq, lambda a: a.bibtex_cite_key)
         return [a.cite_number for a in deduped]
 
     def unpack_cite_seq(self, citation_seq: List[int]) -> str:

fabricatio/models/extra/article_base.py

@@ -18,6 +18,7 @@ from fabricatio.models.generic import (
     Titled,
     WordCount,
 )
+from fabricatio.rust import comment
 from pydantic import Field
 
 
@@ -29,11 +30,9 @@ class ReferringType(StrEnum):
     SUBSECTION = "subsection"
 
 
-
 type RefKey = Tuple[str, Optional[str], Optional[str]]
 
 
-
 class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
     """Metadata for an article component."""
 
@@ -48,8 +47,6 @@ class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
     """List of writing aims of the research component in academic style."""
 
 
-
-
 class ArticleOutlineBase(
     ArticleMetaData,
     ResolveUpdateConflict,
@@ -92,7 +89,13 @@ class SubSectionBase(ArticleOutlineBase):
 
     def to_typst_code(self) -> str:
         """Converts the component into a Typst code snippet for rendering."""
-        return f"=== {self.title}\n"
+        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 ""
+        )
 
     def introspect(self) -> str:
         """Introspects the article subsection outline."""
@@ -117,7 +120,13 @@ class SectionBase[T: SubSectionBase](ArticleOutlineBase):
         Returns:
             str: The formatted Typst code snippet.
         """
-        return f"== {self.title}\n" + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
+        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)
 
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
@@ -160,7 +169,13 @@ 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" + "\n\n".join(sec.to_typst_code() for sec in self.sections)
+        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)
 
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
@@ -302,4 +317,8 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Descri
             === Implementation Details
             == Evaluation Protocol
         """
-        return "\n\n".join(a.to_typst_code() for a in self.chapters)
+        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)

fabricatio/models/extra/article_main.py

@@ -16,7 +16,7 @@ from fabricatio.models.extra.article_outline import (
 )
 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 pydantic import Field
+from pydantic import Field, NonNegativeInt
 
 PARAGRAPH_SEP = "// - - -"
 
@@ -24,6 +24,9 @@ PARAGRAPH_SEP = "// - - -"
 class Paragraph(SketchedAble, WordCount, Described):
     """Structured academic paragraph blueprint for controlled content generation."""
 
+    expected_word_count: NonNegativeInt = 0
+    """The expected word count of this paragraph, 0 means not specified"""
+
     description: str = Field(
         alias="elaboration",
         description=Described.model_fields["description"].description,
@@ -239,6 +242,9 @@ class Article(
     @precheck_package(
         "questionary", "'questionary' is required to run this function. Have you installed `fabricatio[qa]`?."
     )
-    def edit_titles(self) -> Self:
+    async def edit_titles(self) -> Self:
+        """Edits the titles of the article."""
+        from questionary import text
+
         for a in self.iter_dfs():
-            pass
+            a.title = await text(f"Edit `{a.title}`.", default=a.title).ask_async() or a.title