fabricatio 0.2.9.dev4__tar.gz → 0.2.10.dev1__tar.gz

{fabricatio-0.2.9.dev4 → fabricatio-0.2.10.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.9.dev4
+Version: 0.2.10.dev1
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -23,7 +23,6 @@ Requires-Dist: pymitter>=1.0.0
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
-Requires-Dist: rtoml>=0.12.0
 Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
 Requires-Dist: fabricatio[calc,plot,rag] ; extra == 'full'
 Requires-Dist: sympy>=1.13.3 ; extra == 'calc'
@@ -45,8 +44,6 @@ Project-URL: Issues, https://github.com/Whth/fabricatio/issues
 # Fabricatio
 
 ![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)
-![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)
-![Build Status](https://img.shields.io/badge/build-passing-brightgreen)
 
 ## Overview
 

{fabricatio-0.2.9.dev4 → fabricatio-0.2.10.dev1}/README.md

@@ -1,8 +1,6 @@
 # Fabricatio
 
 ![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)
-![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)
-![Build Status](https://img.shields.io/badge/build-passing-brightgreen)
 
 ## Overview
 

{fabricatio-0.2.9.dev4 → fabricatio-0.2.10.dev1}/examples/extract_and_inject/.gitignore

@@ -1,3 +1,4 @@
 bpdf_out
 output*
-ref.bib
+ref.bib
+bare_md

{fabricatio-0.2.9.dev4 → fabricatio-0.2.10.dev1}/examples/extract_and_inject/ask.py

@@ -2,8 +2,10 @@
 
 import asyncio
 
-from fabricatio import RAG, Action, Role, Task, WorkFlow, logger
+from fabricatio import Action, Role, Task, WorkFlow, logger
+from fabricatio.capabilities.rag import RAG
 from fabricatio.models.events import Event
+from fabricatio.models.extra.aricle_rag import ArticleChunk
 from fabricatio.utils import ok
 from questionary import text
 
@@ -23,14 +25,14 @@ class Talk(Action, RAG):
                 user_say = await text("User: ").ask_async()
                 if user_say is None:
                     break
-                gpt_say = await self.aask_refined(
-                    user_say,
-                    "article_essence_max",
-                    extra_system_message=f"You have to answer to user obeying task assigned to you:\n{task_input.briefing}\nYou should explicitly say write a label if you draw a conclusion from the references, the label shall contain names.",
-                    result_per_query=16,
-                    final_limit=40,
-                    similarity_threshold=0.31,
-                )
+                ref_q = ok(await self.arefined_query(user_say))
+                logger.info(f'refined query: \n{ref_q}')
+                ret = await self.aretrieve(ref_q, document_model=ArticleChunk)
+
+                sys_msg = "\n".join(r.as_prompt() for r in ret)
+                logger.info(f"System message: \n{sys_msg}")
+                gpt_say = await self.aask(user_say, sys_msg)
+
                 print(f"GPT: {gpt_say}")  # noqa: T201
                 counter += 1
         except KeyboardInterrupt:
@@ -40,18 +42,15 @@ class Talk(Action, RAG):
 
 async def main() -> None:
     """Main function."""
-    role = Role(
+    Role(
         name="talker",
         description="talker role but with rag",
-        registry={Event.instantiate_from("talk").push_wildcard().push("pending"): WorkFlow(name="talk", steps=(Talk,))},
+        registry={
+            Event.quick_instantiate("talk"): WorkFlow(name="talk", steps=(Talk(target_collection="article_chunks"),))
+        },
     )
 
-    task = ok(
-        await role.propose_task(
-            "you have to act as a helpful assistant, answer to all user questions properly and patiently"
-        ),
-        "Failed to propose task",
-    )
+    task = Task(name="answer user's questions")
     _ = await task.delegate("talk")
 
 

fabricatio-0.2.10.dev1/examples/extract_and_inject/chunk_article.py

@@ -0,0 +1,41 @@
+"""Example of proposing a task to a role."""
+
+import asyncio
+
+from fabricatio import BibManager, Event, Role, Task, WorkFlow, logger
+from fabricatio.actions.article_rag import ChunkArticle
+from fabricatio.actions.rag import InjectToDB
+from fabricatio.fs import gather_files
+from fabricatio.utils import ok
+
+
+async def main() -> None:
+    """Main function."""
+    Role(
+        name="Researcher",
+        description="chunk the article",
+        llm_rpm=50,
+        llm_tpm=100000,
+        registry={
+            Event.quick_instantiate(e := "Chunk"): WorkFlow(
+                name="Chunk",
+                steps=(
+                    ChunkArticle(output_key="to_inject"),
+                    InjectToDB(collection_name="article_chunks").to_task_output(),
+                ),
+            ).update_init_context(
+                article_path=gather_files("bare_md", "md"),
+                bib_manager=BibManager(path="ref.bib"),
+                max_chunk_size=500,
+                max_overlapping_rate=0.3,
+            ),
+        },
+    )
+
+    task: Task[str] = Task(name="Chunk Article")
+    res = ok(await task.delegate(e))
+    logger.success(f"Injected to {res}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.9.dev4 → fabricatio-0.2.10.dev1}/examples/search_bibtex/search.py

@@ -3,7 +3,7 @@ from fabricatio import BibManager, logger
 
 b = BibManager("Exported Items.bib")
 logger.success(
-    b.get_cite_key("A Negative Selection Immune System Inspired Methodology for Fault Diagnosis of Wind Turbines"))
+    b.get_cite_key_by_title("A Negative Selection Immune System Inspired Methodology for Fault Diagnosis of Wind Turbines"))
 logger.success(
     b.get_cite_key_fuzzy(
         "System Inspired Methodology for Fault"

fabricatio-0.2.10.dev1/examples/write_article/write_article.py

@@ -0,0 +1,241 @@
+"""Example of using the library."""
+
+import asyncio
+from pathlib import Path
+from typing import List
+
+from fabricatio import Event, Role, WorkFlow, logger
+from fabricatio.actions.article import (
+    FixIntrospectedErrors,
+    GenerateArticle,
+    GenerateArticleProposal,
+    GenerateInitialOutline,
+)
+from fabricatio.actions.article_rag import TweakArticleRAG
+from fabricatio.actions.output import DumpFinalizedOutput, GatherAsList, PersistentAll, RetrieveFromLatest
+from fabricatio.actions.rules import DraftRuleSet, GatherRuleset
+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.extra.rule import RuleSet
+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, rule: bool = False, fintune: bool = False) -> None:
+    """Main function."""
+    Role(
+        name="Undergraduate Researcher",
+        description="Write an outline for an article in typst format.",
+        llm_model="openai/deepseek-v3-250324",
+        llm_temperature=1.3,
+        llm_top_p=1.0,
+        llm_max_tokens=8191,
+        llm_rpm=1000,
+        llm_tpm=5000000,
+        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=(
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/outline_ruleset",
+                        output_key="outline_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/dep_ref_ruleset",
+                        output_key="dep_ref_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/rev_dep_ref_ruleset",
+                        output_key="rev_dep_ref_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/cite_ruleset", output_key="cite_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/para_ruleset", output_key="para_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/ref_ruleset", output_key="ref_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/lang_ruleset", output_key="lang_ruleset"
+                    ),
+                    GenerateArticleProposal(llm_temperature=1.3),
+                    GenerateInitialOutline(
+                        output_key="article_outline",
+                    ),
+                    GatherRuleset(output_key="intro_fix_ruleset", to_gather=["para_ruleset"]),
+                    FixIntrospectedErrors(
+                        output_key="article_outline",
+                    ),
+                    PersistentAll,
+                    GatherRuleset(output_key="ref_fix_ruleset", to_gather=["ref_ruleset"]),
+                    GatherRuleset(output_key="ref_twk_ruleset", to_gather=["dep_ref_ruleset", "ref_ruleset"]),
+                    GatherRuleset(output_key="article_gen_ruleset", to_gather=["para_ruleset"]),
+                    GenerateArticle(
+                        output_key="article",
+                    ),
+                    PersistentAll,
+                    GatherRuleset(
+                        output_key="twk_rag_ruleset", to_gather=["para_ruleset", "cite_ruleset", "lang_ruleset"]
+                    ),
+                    TweakArticleRAG(output_key="to_dump"),
+                    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_essence_0324",
+            ),
+            Event.quick_instantiate(finetune := "article_finetune"): WorkFlow(
+                name="Generate Article Outline",
+                description="Generate an outline for an article. dump the outline to the given path. in typst format.",
+                steps=(
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/outline_ruleset",
+                        output_key="outline_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/dep_ref_ruleset",
+                        output_key="dep_ref_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet,
+                        load_path="persistent_ruleset/rev_dep_ref_ruleset",
+                        output_key="rev_dep_ref_ruleset",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/cite_ruleset", output_key="cite_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/para_ruleset", output_key="para_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=RuleSet, load_path="persistent_ruleset/ref_ruleset", output_key="ref_ruleset"
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=ArticleProposal,
+                        load_path="persistent/article_proposal",
+                        output_key="article_proposal",
+                    ),
+                    RetrieveFromLatest(
+                        retrieve_cls=ArticleOutline,
+                        load_path="persistent/article_outline",
+                        output_key="article_outline",
+                    ),
+                    RetrieveFromLatest(retrieve_cls=Article, load_path="persistent/article", output_key="article"),
+                    Connect,
+                    GatherRuleset(output_key="intro_fix_ruleset", to_gather=["para_ruleset"]),
+                    GatherRuleset(output_key="ref_fix_ruleset", to_gather=["ref_ruleset"]),
+                    GatherRuleset(output_key="article_gen_ruleset", to_gather=["para_ruleset"]),
+                    GatherRuleset(output_key="twk_rag_ruleset", to_gather=["para_ruleset", "cite_ruleset"]),
+                    TweakArticleRAG(
+                        output_key="to_dump",
+                    ),
+                    DumpFinalizedOutput(output_key="task_output"),
+                    PersistentAll,
+                ),
+            ).update_init_context(
+                article_briefing=Path("./article_briefing.txt").read_text(),
+                dump_path="out_fix.typ",
+                persist_dir="persistent_fix",
+                collection_name="article_essence_0324",
+            ),
+            Event.quick_instantiate(rule_ns := "rule"): WorkFlow(
+                name="Generate Draft Rule Set",
+                description="Generate a draft rule set for the article.",
+                llm_model="openai/deepseek-v3-250324",
+                llm_stream=False,
+                steps=(
+                    # 精简后的para_ruleset规则
+                    DraftRuleSet(
+                        ruleset_requirement="如果`paragraphs`字段为空列表，那么你就需要按照`expected_word_count`来为章节补充内容",
+                        output_key="para_ruleset",
+                        rule_count=1,
+                    ),
+                    # 精简后的cite_ruleset规则
+                    DraftRuleSet(
+                        ruleset_requirement="1. 参考文献引用格式：(作者等, 年份)#cite(<bibtex_key>)\n"
+                        "2. #cite()必须用尖括号包裹单个BibTeX键，多引用需重复使用",
+                        output_key="cite_ruleset",
+                        rule_count=1,
+                    ),
+                    # 新增中文检测规则集
+                    DraftRuleSet(
+                        ruleset_requirement="1. 所有标题和正文内容必须使用中文,如果不为中文你需要翻译过来\n"
+                        "2. 术语和专业词汇需使用中文表述,英文缩写第一次出现的时候需要在其后面‘()’来辅助说明",
+                        output_key="lang_ruleset",
+                        rule_count=1,
+                    ),
+                    # 其他规则集保持原有结构但简化内容
+                    DraftRuleSet(
+                        ruleset_requirement="章节的`depend_on`字段的`ArticleRef`只能引用当前章节之前的元素。\n",
+                        output_key="dep_ref_ruleset",
+                        rule_count=1,
+                    ),
+                    DraftRuleSet(
+                        ruleset_requirement="章节的`support_to`字段的`ArticleRef`只能引用当前章节之后的元素。\n",
+                        output_key="rev_dep_ref_ruleset",
+                        rule_count=1,
+                    ),
+                    DraftRuleSet(
+                        ruleset_requirement="ArticleRef必须指向已定义元素",
+                        output_key="ref_ruleset",
+                        rule_count=1,
+                    ),
+                    DraftRuleSet(
+                        ruleset_requirement="标题使用学术术语",
+                        output_key="outline_ruleset",
+                        rule_count=1,
+                    ),
+                    GatherAsList(gather_suffix="ruleset").to_task_output(),
+                    PersistentAll(persist_dir="persistent_ruleset"),
+                ),
+            ),
+        },
+    )
+
+    if rule:
+        draft_rule_task: Task[List[RuleSet]] = Task(name="draft a rule set")
+        rule_set = ok(await draft_rule_task.delegate(rule_ns), "Failed to generate ruleset")
+        logger.success(f"Ruleset:\n{len(rule_set)}")
+    if article:
+        proposed_task = Task(name="write an article")
+        path = ok(await proposed_task.delegate(ns), "Failed to generate ruleset")
+        logger.success(f"The outline is saved in:\n{path}")
+    if fintune:
+        proposed_task = Task(name="finetune an article")
+        path = ok(await proposed_task.delegate(finetune), "Failed to generate ruleset")
+        logger.success(f"The outline is saved in:\n{path}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main(True, False, False))

{fabricatio-0.2.9.dev4 → fabricatio-0.2.10.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.9-dev4"
+version = "0.2.10-dev1"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -42,7 +42,6 @@ dependencies = [
     "questionary>=2.1.0",
     "regex>=2024.11.6",
     "rich>=13.9.4",
-    "rtoml>=0.12.0",
 ]
 
 [project.urls]

{fabricatio-0.2.9.dev4 → fabricatio-0.2.10.dev1}/python/fabricatio/actions/article.py

@@ -4,6 +4,7 @@ from asyncio import gather
 from pathlib import Path
 from typing import Callable, List, Optional
 
+from fabricatio.rust import BibManager, detect_language
 from more_itertools import filter_map
 
 from fabricatio.capabilities.censor import Censor
@@ -11,14 +12,12 @@ from fabricatio.capabilities.propose import Propose
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.extra.article_base import SubSectionBase
 from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.task import Task
-from fabricatio.rust import BibManager, detect_language
 from fabricatio.utils import ok
 
 
@@ -79,7 +78,7 @@ class FixArticleEssence(Action):
         out = []
         count = 0
         for a in article_essence:
-            if key := (bib_mgr.get_cite_key(a.title) or bib_mgr.get_cite_key_fuzzy(a.title)):
+            if key := (bib_mgr.get_cite_key_by_title(a.title) or bib_mgr.get_cite_key_fuzzy(a.title)):
                 a.title = bib_mgr.get_title_by_key(key) or a.title
                 a.authors = bib_mgr.get_author_by_key(key) or a.authors
                 a.publication_year = bib_mgr.get_year_by_key(key) or a.publication_year
@@ -142,11 +141,17 @@ class GenerateInitialOutline(Action, Propose):
         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"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.",
+        )
+
         return ok(
             await self.propose(
                 ArticleOutline,
-                f"{(article_proposal.as_prompt())}\n\nNote that you should use `{article_proposal.language}` to write the `ArticleOutline`\n"
-                f"You Must make sure every chapter have sections, and every section have subsections.",
+                f"{raw_outline}\n\n\n\noutline provided above is the outline i need to extract to a JSON,",
             ),
             "Could not generate the initial outline.",
         ).update_ref(article_proposal)
@@ -178,7 +183,7 @@ class FixIntrospectedErrors(Action, Censor):
                 await self.censor_obj(
                     article_outline,
                     ruleset=ok(intro_fix_ruleset or self.ruleset, "No ruleset provided"),
-                    reference=f"{article_outline.as_prompt()}\n # Fatal Error of the Original Article Outline\n{pack}",
+                    reference=f"{article_outline.display()}\n # Fatal Error of the Original Article Outline\n{pack}",
                 ),
                 "Could not correct the component.",
             ).update_ref(origin)
@@ -191,107 +196,6 @@ class FixIntrospectedErrors(Action, Censor):
         return article_outline
 
 
-class FixIllegalReferences(Action, Censor):
-    """Fix illegal references in the article outline."""
-
-    output_key: str = "illegal_references_fixed_outline"
-    """The key of the output data."""
-
-    ruleset: Optional[RuleSet] = None
-    """Ruleset to use to fix the illegal references."""
-    max_error_count: Optional[int] = None
-    """The maximum number of errors to fix."""
-
-    async def _execute(
-        self,
-        article_outline: ArticleOutline,
-        ref_fix_ruleset: Optional[RuleSet] = None,
-        **_,
-    ) -> Optional[ArticleOutline]:
-        counter = 0
-        while pack := article_outline.find_illegal_ref(gather_identical=True):
-            logger.info(f"Found {counter}th illegal references")
-            ref_seq, err = ok(pack)
-            logger.warning(f"Found illegal referring error: {err}")
-            new = ok(
-                await self.censor_obj(
-                    ref_seq[0],
-                    ruleset=ok(ref_fix_ruleset or self.ruleset, "No ruleset provided"),
-                    reference=f"{article_outline.as_prompt()}\n# Some Basic errors found that need to be fixed\n{err}",
-                ),
-                "Could not correct the component",
-            )
-            for r in ref_seq:
-                r.update_from(new)
-            if self.max_error_count and counter > self.max_error_count:
-                logger.warning("Max error count reached, stopping.")
-                break
-            counter += 1
-
-        return article_outline
-
-
-class TweakOutlineForwardRef(Action, Censor):
-    """Tweak the forward references in the article outline.
-
-    Ensures that the conclusions of the current chapter effectively support the analysis of subsequent chapters.
-    """
-
-    output_key: str = "article_outline_fw_ref_checked"
-    ruleset: Optional[RuleSet] = None
-    """Ruleset to use to fix the illegal references."""
-
-    async def _execute(
-        self, article_outline: ArticleOutline, ref_twk_ruleset: Optional[RuleSet] = None, **cxt
-    ) -> ArticleOutline:
-        return await self._inner(
-            article_outline,
-            ruleset=ok(ref_twk_ruleset or self.ruleset, "No ruleset provided"),
-            field_name="support_to",
-        )
-
-    async def _inner(self, article_outline: ArticleOutline, ruleset: RuleSet, field_name: str) -> ArticleOutline:
-        await gather(
-            *[self._loop(a[-1], article_outline, field_name, ruleset) for a in article_outline.iter_subsections()],
-        )
-
-        return article_outline
-
-    async def _loop(
-        self, a: SubSectionBase, article_outline: ArticleOutline, field_name: str, ruleset: RuleSet
-    ) -> None:
-        if judge := await self.evidently_judge(
-            f"{article_outline.as_prompt()}\n\n{a.display()}\n"
-            f"Does the `{a.__class__.__name__}`'s `{field_name}` field need to be extended or tweaked?"
-        ):
-            await self.censor_obj_inplace(
-                a,
-                ruleset=ruleset,
-                reference=f"{article_outline.as_prompt()}\n"
-                f"The Article component titled `{a.title}` whose `{field_name}` field needs to be extended or tweaked.\n"
-                f"# Judgement\n{judge.display()}",
-            )
-
-
-class TweakOutlineBackwardRef(TweakOutlineForwardRef):
-    """Tweak the backward references in the article outline.
-
-    Ensures that the prerequisites of the current chapter are correctly referenced in the `depend_on` field.
-    """
-
-    output_key: str = "article_outline_bw_ref_checked"
-    ruleset: Optional[RuleSet] = None
-
-    async def _execute(
-        self, article_outline: ArticleOutline, ref_twk_ruleset: Optional[RuleSet] = None, **cxt
-    ) -> ArticleOutline:
-        return await self._inner(
-            article_outline,
-            ruleset=ok(ref_twk_ruleset or self.ruleset, "No ruleset provided"),
-            field_name="depend_on",
-        )
-
-
 class GenerateArticle(Action, Censor):
     """Generate the article based on the outline."""
 

{fabricatio-0.2.9.dev4 → fabricatio-0.2.10.dev1}/python/fabricatio/actions/article_rag.py

@@ -1,11 +1,15 @@
 """A module for writing articles using RAG (Retrieval-Augmented Generation) capabilities."""
 
 from asyncio import gather
-from typing import Optional
+from pathlib import Path
+from typing import List, Optional
 
+from fabricatio import BibManager
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.rag import RAG
 from fabricatio.models.action import Action
+from fabricatio.models.extra.aricle_rag import ArticleChunk
+from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article, ArticleSubsection
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.utils import ok
@@ -97,9 +101,36 @@ class TweakArticleRAG(Action, RAG, Censor):
         await self.censor_obj_inplace(
             subsec,
             ruleset=ruleset,
-            reference=f"{await self.aretrieve_compact(refind_q, final_limit=self.ref_limit)}\n\n"
+            reference=f"{'\n\n'.join(d.display() for d in await self.aretrieve(refind_q, document_model=ArticleEssence, final_limit=self.ref_limit))}\n\n"
             f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
             f"You should Always use `{subsec.language}` as written language, "
             f"which is the original language of the `{subsec.title}`. "
             f"since rewrite a `{subsec.__class__.__name__}` in a different language is usually a bad choice",
         )
+
+
+class ChunkArticle(Action):
+    """Chunk an article into smaller chunks."""
+
+    output_key:str = "article_chunks"
+    """The key used to store the output of the action."""
+    max_chunk_size: Optional[int] = None
+    """The maximum size of each chunk."""
+    max_overlapping_rate: Optional[float] = None
+    """The maximum overlapping rate between chunks."""
+
+    async def _execute(
+        self,
+        article_path: str | Path,
+        bib_manager: BibManager,
+        max_chunk_size: Optional[int] = None,
+        max_overlapping_rate: Optional[float] = None,
+        **_,
+    ) -> List[ArticleChunk]:
+        return ArticleChunk.from_file(
+            article_path,
+            bib_manager,
+            max_chunk_size=ok(max_chunk_size or self.max_chunk_size, "No max_chunk_size provided!"),
+            max_overlapping_rate=ok(max_overlapping_rate or self.max_overlapping_rate, "No max_overlapping_rate provided!"),
+        )
+