fabricatio 0.2.13.dev3__cp312-cp312-win_amd64.whl → 0.3.13__cp312-cp312-win_amd64.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,13 +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_all_block_tex,
-    convert_all_inline_tex,
-    convert_to_block_formula,
-    convert_to_inline_formula,
-    fix_misplaced_labels,
-)
 from fabricatio.utils import ok
 
 TYPST_CITE_USAGE = (
@@ -78,11 +78,11 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
     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
@@ -103,12 +103,12 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
         "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
@@ -137,12 +137,12 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
         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()
 
@@ -159,7 +159,7 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
         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(
@@ -182,14 +182,14 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
         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(
@@ -205,14 +205,14 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
         )
 
     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 = (
@@ -321,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.
 
@@ -381,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",
         )
 
 
@@ -399,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(

fabricatio/capabilities/check.py

@@ -3,17 +3,16 @@
 from asyncio import gather
 from typing import List, Optional, Unpack
 
-from fabricatio import TEMPLATE_MANAGER
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, detect_language
+
 from fabricatio.capabilities.advanced_judge import AdvancedJudge
 from fabricatio.capabilities.propose import Propose
-from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.extra.patches import RuleSetMetadata
 from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.extra.rule import Rule, RuleSet
 from fabricatio.models.generic import Display, WithBriefing
 from fabricatio.models.kwargs_types import ValidateKwargs
-from fabricatio.rust import detect_language
 from fabricatio.utils import override_kwargs
 
 
@@ -25,7 +24,7 @@ class Check(AdvancedJudge, Propose):
     """
 
     async def draft_ruleset(
-        self, ruleset_requirement: str, rule_count: int = 0, **kwargs: Unpack[ValidateKwargs[Rule]]
+            self, ruleset_requirement: str, rule_count: int = 0, **kwargs: Unpack[ValidateKwargs[Rule]]
     ) -> Optional[RuleSet]:
         """Generate rule set based on requirement description.
 
@@ -45,7 +44,7 @@ class Check(AdvancedJudge, Propose):
         rule_reqs = (
             await self.alist_str(
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.ruleset_requirement_breakdown_template,
+                    CONFIG.templates.ruleset_requirement_breakdown_template,
                     {"ruleset_requirement": ruleset_requirement},
                 ),
                 rule_count,
@@ -61,7 +60,7 @@ class Check(AdvancedJudge, Propose):
         rules = await self.propose(
             Rule,
             [
-                TEMPLATE_MANAGER.render_template(configs.templates.rule_requirement_template, {"rule_requirement": r})
+                TEMPLATE_MANAGER.render_template(CONFIG.templates.rule_requirement_template, {"rule_requirement": r})
                 for r in rule_reqs
             ],
             **kwargs,
@@ -81,11 +80,11 @@ class Check(AdvancedJudge, Propose):
         return RuleSet(rules=rules, **ruleset_patch.as_kwargs())
 
     async def check_string_against_rule(
-        self,
-        input_text: str,
-        rule: Rule,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
+            self,
+            input_text: str,
+            rule: Rule,
+            reference: str = "",
+            **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[Improvement]:
         """Validate text against specific rule.
 
@@ -104,15 +103,15 @@ class Check(AdvancedJudge, Propose):
             - Proposes Improvement only when violation is confirmed
         """
         if judge := await self.evidently_judge(
-            f"# Content to exam\n{input_text}\n\n# Rule Must to follow\n{rule.display()}\nDoes `Content to exam` provided above violate the `{rule.name}` provided above?"
-            f"should I take some measure to fix that violation? true for I do need, false for I don't need.",
-            **override_kwargs(kwargs, default=None),
+                f"# Content to exam\n{input_text}\n\n# Rule Must to follow\n{rule.display()}\nDoes `Content to exam` provided above violate the `{rule.name}` provided above?"
+                f"should I take some measure to fix that violation? true for I do need, false for I don't need.",
+                **override_kwargs(kwargs, default=None),
         ):
             logger.info(f"Rule `{rule.name}` violated: \n{judge.display()}")
             return await self.propose(
                 Improvement,
                 TEMPLATE_MANAGER.render_template(
-                    configs.templates.check_string_template,
+                    CONFIG.templates.check_string_template,
                     {"to_check": input_text, "rule": rule.display(), "judge": judge.display(), "reference": reference},
                 ),
                 **kwargs,
@@ -120,11 +119,11 @@ class Check(AdvancedJudge, Propose):
         return None
 
     async def check_obj_against_rule[M: (Display, WithBriefing)](
-        self,
-        obj: M,
-        rule: Rule,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
+            self,
+            obj: M,
+            rule: Rule,
+            reference: str = "",
+            **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[Improvement]:
         """Validate object against rule using text representation.
 
@@ -152,11 +151,11 @@ class Check(AdvancedJudge, Propose):
         return await self.check_string_against_rule(input_text, rule, reference, **kwargs)
 
     async def check_string(
-        self,
-        input_text: str,
-        ruleset: RuleSet,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
+            self,
+            input_text: str,
+            ruleset: RuleSet,
+            reference: str = "",
+            **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[List[Improvement]]:
         """Validate text against full ruleset.
 
@@ -183,11 +182,11 @@ class Check(AdvancedJudge, Propose):
         return [imp for imp in imp_seq if imp]
 
     async def check_obj[M: (Display, WithBriefing)](
-        self,
-        obj: M,
-        ruleset: RuleSet,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
+            self,
+            obj: M,
+            ruleset: RuleSet,
+            reference: str = "",
+            **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[List[Improvement]]:
         """Validate object against full ruleset.