fabricatio 0.2.13.dev2__cp312-cp312-manylinux_2_34_x86_64.whl → 0.3.13__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/__init__.py

@@ -1,19 +1,19 @@
 """Fabricatio is a Python library for building llm app using event-based agent structure."""
 
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, BibManager, Event
+
 from fabricatio import actions, capabilities, toolboxes, workflows
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models import extra
 from fabricatio.models.action import Action, WorkFlow
-from fabricatio.models.events import Event
 from fabricatio.models.role import Role
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
 from fabricatio.parser import Capture, GenericCapture, JsonCapture, PythonCapture
-from fabricatio.rust import BibManager
-from fabricatio.rust_instances import TEMPLATE_MANAGER
 
 __all__ = [
+    "CONFIG",
     "TEMPLATE_MANAGER",
     "Action",
     "BibManager",

fabricatio/actions/article.py

@@ -4,15 +4,14 @@ from asyncio import gather
 from pathlib import Path
 from typing import Callable, List, Optional
 
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, BibManager, detect_language
 from more_itertools import filter_map
 from pydantic import Field
 from rich import print as r_print
 
-from fabricatio import TEMPLATE_MANAGER
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.extract import Extract
 from fabricatio.capabilities.propose import Propose
-from fabricatio.config import configs
 from fabricatio.fs import dump_text, safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
@@ -24,7 +23,6 @@ from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.usages import LLMUsage
-from fabricatio.rust import BibManager, detect_language
 from fabricatio.utils import ok, wrapp_in_block
 
 
@@ -40,10 +38,10 @@ class ExtractArticleEssence(Action, Propose):
     """The key of the output data."""
 
     async def _execute(
-        self,
-        task_input: Task,
-        reader: Callable[[str], Optional[str]] = lambda p: Path(p).read_text(encoding="utf-8"),
-        **_,
+            self,
+            task_input: Task,
+            reader: Callable[[str], Optional[str]] = lambda p: Path(p).read_text(encoding="utf-8"),
+            **_,
     ) -> List[ArticleEssence]:
         if not task_input.dependencies:
             logger.info(err := "Task not approved, since no dependencies are provided.")
@@ -56,11 +54,11 @@ class ExtractArticleEssence(Action, Propose):
         out = []
 
         for ess in await self.propose(
-            ArticleEssence,
-            [
-                f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it.\n\nWrite the value string using `{detect_language(c)}`"
-                for c in contents
-            ],
+                ArticleEssence,
+                [
+                    f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it.\n\nWrite the value string using `{detect_language(c)}`"
+                    for c in contents
+                ],
         ):
             if ess is None:
                 logger.warning("Could not extract article essence")
@@ -77,10 +75,10 @@ class FixArticleEssence(Action):
     """The key of the output data."""
 
     async def _execute(
-        self,
-        bib_mgr: BibManager,
-        article_essence: List[ArticleEssence],
-        **_,
+            self,
+            bib_mgr: BibManager,
+            article_essence: List[ArticleEssence],
+            **_,
     ) -> List[ArticleEssence]:
         out = []
         count = 0
@@ -107,11 +105,11 @@ class GenerateArticleProposal(Action, Propose):
     """The key of the output data."""
 
     async def _execute(
-        self,
-        task_input: Optional[Task] = None,
-        article_briefing: Optional[str] = None,
-        article_briefing_path: Optional[str] = None,
-        **_,
+            self,
+            task_input: Optional[Task] = None,
+            article_briefing: Optional[str] = None,
+            article_briefing_path: Optional[str] = None,
+            **_,
     ) -> Optional[ArticleProposal]:
         if article_briefing is None and article_briefing_path is None and task_input is None:
             logger.error("Task not approved, since all inputs are None.")
@@ -150,10 +148,10 @@ class GenerateInitialOutline(Action, Extract):
     """The kwargs to extract the outline."""
 
     async def _execute(
-        self,
-        article_proposal: ArticleProposal,
-        supervisor: Optional[bool] = None,
-        **_,
+            self,
+            article_proposal: ArticleProposal,
+            supervisor: Optional[bool] = None,
+            **_,
     ) -> Optional[ArticleOutline]:
         req = (
             f"Design each chapter of a proper and academic and ready for release manner.\n"
@@ -208,10 +206,10 @@ class FixIntrospectedErrors(Action, Censor):
     """The maximum number of errors to fix."""
 
     async def _execute(
-        self,
-        article_outline: ArticleOutline,
-        intro_fix_ruleset: Optional[RuleSet] = None,
-        **_,
+            self,
+            article_outline: ArticleOutline,
+            intro_fix_ruleset: Optional[RuleSet] = None,
+            **_,
     ) -> Optional[ArticleOutline]:
         counter = 0
         origin = article_outline
@@ -243,10 +241,10 @@ class GenerateArticle(Action, Censor):
     ruleset: Optional[RuleSet] = None
 
     async def _execute(
-        self,
-        article_outline: ArticleOutline,
-        article_gen_ruleset: Optional[RuleSet] = None,
-        **_,
+            self,
+            article_outline: ArticleOutline,
+            article_gen_ruleset: Optional[RuleSet] = None,
+            **_,
     ) -> Optional[Article]:
         article: Article = Article.from_outline(ok(article_outline, "Article outline not specified.")).update_ref(
             article_outline
@@ -296,7 +294,7 @@ class WriteChapterSummary(Action, LLMUsage):
             for raw in (
                 await self.aask(
                     TEMPLATE_MANAGER.render_template(
-                        configs.templates.chap_summary_template,
+                        CONFIG.templates.chap_summary_template,
                         [
                             {
                                 "chapter": a.to_typst_code(),

fabricatio/actions/article_rag.py

@@ -4,9 +4,16 @@ from asyncio import gather
 from pathlib import Path
 from typing import ClassVar, List, Optional
 
+from fabricatio.rust import (
+    BibManager,
+    convert_all_block_tex,
+    convert_all_inline_tex,
+    convert_to_block_formula,
+    convert_to_inline_formula,
+    fix_misplaced_labels,
+)
 from pydantic import Field, PositiveInt
 
-from fabricatio import BibManager
 from fabricatio.capabilities.advanced_rag import AdvancedRAG
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.extract import Extract
@@ -20,7 +27,6 @@ from fabricatio.models.extra.article_main import Article, ArticleChapter, Articl
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.kwargs_types import ChooseKwargs, LLMKwargs
-from fabricatio.rust import convert_to_block_formula, convert_to_inline_formula
 from fabricatio.utils import ok
 
 TYPST_CITE_USAGE = (
@@ -28,8 +34,10 @@ TYPST_CITE_USAGE = (
     "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"
     "You SHALL not cite a single reference more than once!"
-    "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"
+)
+
+TYPST_MATH_USAGE = (
     "Wrap inline expression with '\\(' and '\\)',like '\\(>5m\\)' '\\(89%\\)', and wrap block equation with '\\[' and '\\]'.\n"
     "In addition to that, you can add a label outside the block equation which can be used as a cross reference identifier, the label is a string wrapped in `<` and `>` like `<energy-release-rate-equation>`.Note that the label string should be a summarizing title for the equation being labeled and should never be written within the formula block.\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."
@@ -44,7 +52,7 @@ TYPST_CITE_USAGE = (
 )
 
 
-class WriteArticleContentRAG(Action, RAG, Extract):
+class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
     """Write an article based on the provided outline."""
 
     ctx_override: ClassVar[bool] = True
@@ -56,22 +64,25 @@ class WriteArticleContentRAG(Action, RAG, Extract):
     """The threshold of relevance"""
     extractor_model: LLMKwargs
     """The model to use for extracting the content from the retrieved references."""
-    query_model: LLMKwargs
+    query_model: ChooseKwargs
     """The model to use for querying the database"""
     supervisor: bool = False
     """Whether to use supervisor mode"""
     result_per_query: PositiveInt = 4
     """The number of results to be returned per query."""
-    req: str = TYPST_CITE_USAGE
+    cite_req: str = TYPST_CITE_USAGE
+    """The req of the write article content."""
+
+    math_req: str = TYPST_MATH_USAGE
     """The req of the write article content."""
     tei_endpoint: Optional[str] = None
 
     async def _execute(
-        self,
-        article_outline: ArticleOutline,
-        collection_name: Optional[str] = None,
-        supervisor: Optional[bool] = None,
-        **cxt,
+            self,
+            article_outline: ArticleOutline,
+            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
@@ -92,12 +103,12 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         "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,
+            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
@@ -105,29 +116,33 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         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)
+        raw_paras = await self.write_raw(article, article_outline, chap, sec, subsec, cm)
+        r_print(raw_paras)
 
         while not await confirm("Accept this version and continue?").ask_async():
             if inst := await text("Search for more refs for additional spec.").ask_async():
                 await self.search_database(article, article_outline, chap, sec, subsec, cm, extra_instruction=inst)
 
             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
+                raw_paras = await self.write_raw(article, article_outline, chap, sec, subsec, cm, instruction)
+            if edt := await text("Edit", default=raw_paras).ask_async():
+                raw_paras = edt
+
+            raw_paras = fix_misplaced_labels(raw_paras)
+            raw_paras = convert_all_inline_tex(raw_paras)
+            raw_paras = convert_all_block_tex(raw_paras)
 
-            r_print(raw)
+            r_print(raw_paras)
 
-        return await self.extract_new_subsec(subsec, raw, cm)
+        return await self.extract_new_subsec(subsec, raw_paras, cm)
 
     async def _inner(
-        self,
-        article: Article,
-        article_outline: ArticleOutline,
-        chap: ArticleChapter,
-        sec: ArticleSection,
-        subsec: ArticleSubsection,
+            self,
+            article: Article,
+            article_outline: ArticleOutline,
+            chap: ArticleChapter,
+            sec: ArticleSection,
+            subsec: ArticleSubsection,
     ) -> ArticleSubsection:
         cm = CitationManager()
 
@@ -137,10 +152,14 @@ class WriteArticleContentRAG(Action, RAG, Extract):
 
         raw_paras = "\n".join(p for p in raw_paras.splitlines() if p and not p.endswith("**") and not p.startswith("#"))
 
+        raw_paras = fix_misplaced_labels(raw_paras)
+        raw_paras = convert_all_inline_tex(raw_paras)
+        raw_paras = convert_all_block_tex(raw_paras)
+
         return await self.extract_new_subsec(subsec, raw_paras, cm)
 
     async def extract_new_subsec(
-        self, subsec: ArticleSubsection, raw_paras: str, cm: CitationManager
+            self, subsec: ArticleSubsection, raw_paras: str, cm: CitationManager
     ) -> ArticleSubsection:
         """Extract the new subsec."""
         new_subsec = ok(
@@ -148,12 +167,13 @@ class WriteArticleContentRAG(Action, RAG, Extract):
                 ArticleSubsection,
                 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",
+                f"I need you to extract the content to construct a new `{ArticleSubsection.__class__.__name__}`,"
+                f"Do not attempt to change the original content, your job is ONLY content extraction",
                 **self.extractor_model,
             ),
             "Failed to propose new subsection.",
         )
+
         for p in new_subsec.paragraphs:
             p.content = cm.apply(p.content)
             p.description = cm.apply(p.description)
@@ -162,14 +182,14 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         return subsec
 
     async def write_raw(
-        self,
-        article: Article,
-        article_outline: ArticleOutline,
-        chap: ArticleChapter,
-        sec: ArticleSection,
-        subsec: ArticleSubsection,
-        cm: CitationManager,
-        extra_instruction: str = "",
+            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(
@@ -177,7 +197,7 @@ class WriteArticleContentRAG(Action, RAG, Extract):
             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"{self.cite_req}\n{self.math_req}\n"
             f"You SHALL use `{article.language}` as writing language.\n{extra_instruction}\n"
             f"Do not use numbered list to display the outcome, you should regard you are writing the main text of the thesis.\n"
             f"You should not copy others' works from the references directly on to my thesis, we can only harness the conclusion they have drawn.\n"
@@ -185,14 +205,14 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         )
 
     async def search_database(
-        self,
-        article: Article,
-        article_outline: ArticleOutline,
-        chap: ArticleChapter,
-        sec: ArticleSection,
-        subsec: ArticleSubsection,
-        cm: CitationManager,
-        extra_instruction: str = "",
+            self,
+            article: Article,
+            article_outline: ArticleOutline,
+            chap: ArticleChapter,
+            sec: ArticleSection,
+            subsec: ArticleSubsection,
+            cm: CitationManager,
+            extra_instruction: str = "",
     ) -> None:
         """Search database for related references."""
         search_req = (
@@ -206,11 +226,11 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         await self.clued_search(
             search_req,
             cm,
-            refinery_kwargs=self.ref_q_model,
+            refinery_kwargs=self.query_model,
             expand_multiplier=self.search_increment_multiplier,
             base_accepted=self.ref_limit,
-            result_per_query=self.ref_per_q,
-            similarity_threshold=self.similarity_threshold,
+            result_per_query=self.result_per_query,
+            similarity_threshold=self.threshold,
             tei_endpoint=self.tei_endpoint,
         )
 
@@ -301,12 +321,12 @@ class TweakArticleRAG(Action, RAG, Censor):
     """The limit of references to be retrieved"""
 
     async def _execute(
-        self,
-        article: Article,
-        collection_name: str = "article_essence",
-        twk_rag_ruleset: Optional[RuleSet] = None,
-        parallel: bool = False,
-        **cxt,
+            self,
+            article: Article,
+            collection_name: str = "article_essence",
+            twk_rag_ruleset: Optional[RuleSet] = None,
+            parallel: bool = False,
+            **cxt,
     ) -> Article:
         """Write an article based on the provided outline.
 
@@ -361,10 +381,10 @@ class TweakArticleRAG(Action, RAG, Censor):
             subsec,
             ruleset=ruleset,
             reference=f"{'\n\n'.join(d.display() for d in await self.aretrieve(refind_q, document_model=ArticleEssence, max_accepted=self.ref_limit))}\n\n"
-            f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
-            f"You should Always use `{subsec.language}` as written language, "
-            f"which is the original language of the `{subsec.title}`. "
-            f"since rewrite a `{subsec.__class__.__name__}` in a different language is usually a bad choice",
+                      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",
         )
 
 
@@ -379,12 +399,12 @@ class ChunkArticle(Action):
     """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,
-        **_,
+            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,

fabricatio/actions/output.py

@@ -3,7 +3,8 @@
 from pathlib import Path
 from typing import Any, Iterable, List, Mapping, Optional, Type
 
-from fabricatio import TEMPLATE_MANAGER
+from fabricatio.rust import TEMPLATE_MANAGER
+
 from fabricatio.fs import dump_text
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
@@ -20,11 +21,11 @@ class DumpFinalizedOutput(Action, LLMUsage):
     dump_path: Optional[str] = None
 
     async def _execute(
-        self,
-        to_dump: FinalizedDumpAble,
-        task_input: Optional[Task] = None,
-        dump_path: Optional[str | Path] = None,
-        **_,
+            self,
+            to_dump: FinalizedDumpAble,
+            task_input: Optional[Task] = None,
+            dump_path: Optional[str | Path] = None,
+            **_,
     ) -> str:
         dump_path = Path(
             dump_path
@@ -51,11 +52,11 @@ class RenderedDump(Action, LLMUsage):
     """The template name to render the data."""
 
     async def _execute(
-        self,
-        to_dump: FinalizedDumpAble,
-        task_input: Optional[Task] = None,
-        dump_path: Optional[str | Path] = None,
-        **_,
+            self,
+            to_dump: FinalizedDumpAble,
+            task_input: Optional[Task] = None,
+            dump_path: Optional[str | Path] = None,
+            **_,
     ) -> str:
         dump_path = Path(
             dump_path
@@ -90,10 +91,10 @@ class PersistentAll(Action, LLMUsage):
     """Whether to remove the existing dir before dumping."""
 
     async def _execute(
-        self,
-        task_input: Optional[Task] = None,
-        persist_dir: Optional[str | Path] = None,
-        **cxt,
+            self,
+            task_input: Optional[Task] = None,
+            persist_dir: Optional[str | Path] = None,
+            **cxt,
     ) -> int:
         persist_dir = Path(
             persist_dir
@@ -123,7 +124,7 @@ class PersistentAll(Action, LLMUsage):
                 v.persist(final_dir)
                 count += 1
             if isinstance(v, Iterable) and any(
-                persistent_ables := (pers for pers in v if isinstance(pers, PersistentAble))
+                    persistent_ables := (pers for pers in v if isinstance(pers, PersistentAble))
             ):
                 logger.info(f"Persisting collection {k} to {final_dir}")
                 final_dir.mkdir(parents=True, exist_ok=True)
@@ -173,11 +174,11 @@ class RetrieveFromLatest[T: PersistentAble](RetrieveFromPersistent[T], FromMappi
 
     @classmethod
     def from_mapping(
-        cls,
-        mapping: Mapping[str, str | Path],
-        *,
-        retrieve_cls: Type[T],
-        **kwargs,
+            cls,
+            mapping: Mapping[str, str | Path],
+            *,
+            retrieve_cls: Type[T],
+            **kwargs,
     ) -> List["RetrieveFromLatest[T]"]:
         """Create a list of `RetrieveFromLatest` from the mapping."""
         return [

fabricatio/actions/rag.py

@@ -2,8 +2,9 @@
 
 from typing import List, Optional
 
+from fabricatio.rust import CONFIG
+
 from fabricatio.capabilities.rag import RAG
-from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra.rag import MilvusClassicModel, MilvusDataBase
@@ -39,9 +40,9 @@ class InjectToDB(Action, RAG):
             schema=seq[0].as_milvus_schema(
                 ok(
                     self.milvus_dimensions
-                    or configs.rag.milvus_dimensions
+                    or CONFIG.rag.milvus_dimensions
                     or self.embedding_dimensions
-                    or configs.embedding.dimensions
+                    or CONFIG.embedding.dimensions
                 ),
             ),
             index_params=IndexParams(