fabricatio 0.2.11.dev1__tar.gz → 0.2.11.dev2__tar.gz

{fabricatio-0.2.11.dev1 → fabricatio-0.2.11.dev2}/PKG-INFO

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

fabricatio-0.2.11.dev2/examples/write_article/write_article.py

@@ -0,0 +1,90 @@
+"""Example of using the library."""
+
+import asyncio
+from pathlib import Path
+
+from fabricatio import Event, Role, WorkFlow, logger
+from fabricatio.actions.article import (
+    GenerateArticleProposal,
+    GenerateInitialOutline,
+)
+from fabricatio.actions.article_rag import WriteArticleContentRAG
+from fabricatio.actions.output import (
+    DumpFinalizedOutput,
+    PersistentAll,
+)
+from fabricatio.models.action import Action
+from fabricatio.models.extra.article_main import Article
+from fabricatio.models.extra.article_outline import ArticleOutline
+from fabricatio.models.extra.article_proposal import ArticleProposal
+from fabricatio.models.task import Task
+from fabricatio.utils import ok
+
+
+class Connect(Action):
+    """Connect the article with the article_outline and article_proposal."""
+
+    output_key: str = "article"
+    """Connect the article with the article_outline and article_proposal."""
+
+    async def _execute(
+        self,
+        article_briefing: str,
+        article_proposal: ArticleProposal,
+        article_outline: ArticleOutline,
+        article: Article,
+        **cxt,
+    ) -> Article:
+        """Connect the article with the article_outline and article_proposal."""
+        return article.update_ref(article_outline.update_ref(article_proposal.update_ref(article_briefing)))
+
+
+async def main(article: bool) -> None:
+    """Main function."""
+    Role(
+        name="Undergraduate Researcher",
+        description="Write an outline for an article in typst format.",
+        llm_model="openai/qwen-max",
+        llm_temperature=0.63,
+        llm_stream=True,
+        llm_top_p=0.85,
+        llm_max_tokens=8191,
+        llm_rpm=600,
+        llm_tpm=900000,
+        registry={
+            Event.quick_instantiate(ns := "article"): WorkFlow(
+                name="Generate Article Outline",
+                description="Generate an outline for an article. dump the outline to the given path. in typst format.",
+                steps=(
+                    GenerateArticleProposal,
+                    GenerateInitialOutline(output_key="article_outline", supervisor=False),
+                    PersistentAll,
+                    WriteArticleContentRAG(
+                        output_key="to_dump",
+                        llm_top_p=0.9,
+                        ref_limit=60,
+                        llm_model="openai/qwq-plus",
+                        target_collection="article_chunks",
+                        extractor_model="openai/qwen-plus",
+                        query_model="openai/qwen-max",
+                    ),
+                    DumpFinalizedOutput(output_key="task_output"),
+                    PersistentAll,
+                ),
+            ).update_init_context(
+                article_briefing=Path("./article_briefing.txt").read_text(),
+                dump_path="out.typ",
+                persist_dir="persistent",
+                collection_name="article_chunks",
+            ),
+        },
+    )
+
+    if article:
+        proposed_task = Task(name="write an article")
+        path = ok(await proposed_task.delegate(ns), "Failed to generate an article ")
+        logger.success(f"The outline is saved in:\n{path}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main(True))

{fabricatio-0.2.11.dev1 → fabricatio-0.2.11.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.11-dev1"
+version = "0.2.11-dev2"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

{fabricatio-0.2.11.dev1 → fabricatio-0.2.11.dev2}/python/fabricatio/actions/article_rag.py

@@ -8,6 +8,7 @@ from fabricatio import BibManager
 from fabricatio.capabilities.censor import Censor
 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,7 +16,7 @@ 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, Extract):
@@ -23,11 +24,14 @@ class WriteArticleContentRAG(Action, RAG, Extract):
 
     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"
@@ -40,12 +44,12 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         "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 equation.\n"
+        "See @eqt:mass-energy-equation , it's the foundation of physics.\n"
         "$$\n"
         "E = m c^2"
         "$$\n"
-        "<mass-energy-equation>"
-        "In @eqt:mass-energy-equation , we get the foundation of physics.\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"
         "```"
     )
 
@@ -57,14 +61,57 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         **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,
@@ -73,35 +120,17 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         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=6)
-        ret.reverse()
-        cm = CitationManager().update_chunks(ret)
-
-        raw_paras = await self.aask(
-            f"{cm.as_prompt()}\nAbove is some related reference retrieved for you."
-            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"{self.req}\n"
-            f"You SHALL use `{article.language}` as writing language."
-        )
+        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.extract(
                 ArticleSubsection,
@@ -112,14 +141,71 @@ class WriteArticleContentRAG(Action, RAG, Extract):
             ),
             "Failed to propose new subsection.",
         )
-
         for p in new_subsec.paragraphs:
             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-0.2.11.dev1 → fabricatio-0.2.11.dev2}/python/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-0.2.11.dev1 → fabricatio-0.2.11.dev2}/python/fabricatio/models/extra/aricle_rag.py

@@ -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):

{fabricatio-0.2.11.dev1 → fabricatio-0.2.11.dev2}/python/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)