fabricatio 0.3.14.dev1__cp312-cp312-manylinux_2_34_x86_64.whl → 0.3.14.dev3__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/__init__.py

@@ -1,20 +1,17 @@
 """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, parser, toolboxes, workflows
+from fabricatio import actions, capabilities, fs, models, parser, toolboxes, utils, workflows
 from fabricatio.journal import logger
-from fabricatio.models import extra
 from fabricatio.models.action import Action, WorkFlow
 from fabricatio.models.role import Role
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, Event
 
 __all__ = [
     "CONFIG",
     "TEMPLATE_MANAGER",
     "Action",
-    "BibManager",
     "Event",
     "Role",
     "Task",
@@ -22,9 +19,11 @@ __all__ = [
     "WorkFlow",
     "actions",
     "capabilities",
-    "extra",
+    "fs",
     "logger",
+    "models",
     "parser",
     "toolboxes",
+    "utils",
     "workflows",
 ]

fabricatio/actions/article.py

@@ -4,7 +4,6 @@ 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
@@ -23,6 +22,7 @@ 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 CONFIG, TEMPLATE_MANAGER, BibManager, detect_language
 from fabricatio.utils import ok, wrapp_in_block
 
 
@@ -38,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.")
@@ -54,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")
@@ -75,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
@@ -105,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.")
@@ -148,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"
@@ -206,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
@@ -241,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

fabricatio/actions/article_rag.py

@@ -4,14 +4,6 @@ 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.capabilities.advanced_rag import AdvancedRAG
@@ -27,6 +19,14 @@ 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 (
+    BibManager,
+    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

@@ -1,16 +1,16 @@
 """Dump the finalized output to a file."""
 
 from pathlib import Path
-from typing import Any, Iterable, List, Mapping, Optional, Type
-
-from fabricatio.rust import TEMPLATE_MANAGER
+from typing import Any, Iterable, List, Mapping, Optional, Self, Sequence, Type
 
+from fabricatio.capabilities.persist import PersistentAble
 from fabricatio.fs import dump_text
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.generic import FinalizedDumpAble, FromMapping, PersistentAble
+from fabricatio.models.generic import FinalizedDumpAble, FromMapping, FromSequence
 from fabricatio.models.task import Task
 from fabricatio.models.usages import LLMUsage
+from fabricatio.rust import TEMPLATE_MANAGER
 from fabricatio.utils import ok
 
 
@@ -21,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
@@ -52,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
@@ -91,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
@@ -124,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)
@@ -174,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 [
@@ -212,3 +212,37 @@ class GatherAsList(Action):
         result = [cxt[k] for k in cxt if k.startswith(self.gather_prefix)]
         logger.debug(f"Gathered {len(result)} items with prefix {self.gather_prefix}")
         return result
+
+
+class Forward(Action, FromMapping, FromSequence):
+    """Forward the object from the context to the output."""
+
+    output_key: str = "forwarded"
+    """Gather the objects from the context as a list."""
+    original: str
+
+    async def _execute(self, *_: Any, **cxt) -> Any:
+        source = cxt.get(self.original)
+        if source is None:
+            logger.warning(f"Original object {self.original} not found in the context")
+        return source
+
+    @classmethod
+    def from_sequence(cls, sequence: Sequence[str], *, original: str, **kwargs: Any) -> List[Self]:
+        """Create a list of `Forward` from the sequence."""
+        return [cls(original=original, output_key=o, **kwargs) for o in sequence]
+
+    @classmethod
+    def from_mapping(cls, mapping: Mapping[str, str | Sequence[str]], **kwargs: Any) -> List[Self]:
+        """Create a list of `Forward` from the mapping."""
+        actions = []
+        for original_key, output_val in mapping.items():
+            if isinstance(output_val, str):
+                actions.append(cls(original=original_key, output_key=output_val, **kwargs))
+            elif isinstance(output_val, Sequence):
+                actions.extend(cls(original=original_key, output_key=output_key, **kwargs) for output_key in output_val)
+            else:
+                logger.warning(
+                    f"Invalid type for output key value in mapping: {type(output_val)} for original key {original_key}. Expected str or Sequence[str]."
+                )
+        return actions

fabricatio/actions/rag.py

@@ -2,13 +2,12 @@
 
 from typing import List, Optional
 
-from fabricatio.rust import CONFIG
-
 from fabricatio.capabilities.rag import RAG
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra.rag import MilvusClassicModel, MilvusDataBase
 from fabricatio.models.task import Task
+from fabricatio.rust import CONFIG
 from fabricatio.utils import ok
 
 
@@ -20,7 +19,7 @@ class InjectToDB(Action, RAG):
     """The name of the collection to inject data into."""
 
     async def _execute[T: MilvusDataBase](
-            self, to_inject: Optional[T] | List[Optional[T]], override_inject: bool = False, **_
+        self, to_inject: Optional[T] | List[Optional[T]], override_inject: bool = False, **_
     ) -> Optional[str]:
         from pymilvus.milvus_client import IndexParams
 

fabricatio/capabilities/advanced_judge.py

@@ -1,5 +1,6 @@
 """The Capabilities module for advanced judging."""
 
+from abc import ABC
 from typing import Optional, Unpack
 
 from fabricatio.capabilities.propose import Propose
@@ -7,17 +8,13 @@ from fabricatio.models.extra.advanced_judge import JudgeMent
 from fabricatio.models.kwargs_types import ValidateKwargs
 
 
-class AdvancedJudge(Propose):
+class AdvancedJudge(Propose, ABC):
     """A class that judges the evidence and makes a final decision."""
+
     async def evidently_judge(
         self,
         prompt: str,
         **kwargs: Unpack[ValidateKwargs[JudgeMent]],
     ) -> Optional[JudgeMent]:
         """Judge the evidence and make a final decision."""
-        return await self.propose(
-            JudgeMent,
-            prompt,
-            **kwargs
-        )
-
+        return await self.propose(JudgeMent, prompt, **kwargs)

fabricatio/capabilities/advanced_rag.py

@@ -1,5 +1,6 @@
 """Advanced RAG (Retrieval Augmented Generation) model."""
 
+from abc import ABC
 from typing import Optional, Unpack
 
 from fabricatio.capabilities.rag import RAG
@@ -10,7 +11,7 @@ from fabricatio.models.kwargs_types import ChooseKwargs
 from fabricatio.utils import fallback_kwargs
 
 
-class AdvancedRAG(RAG):
+class AdvancedRAG(RAG, ABC):
     """A class representing the Advanced RAG (Retrieval Augmented Generation) model."""
 
     async def clued_search(

fabricatio/capabilities/censor.py

@@ -4,6 +4,7 @@ This module includes the Censor class which inherits from both Correct and Check
 It provides methods to censor objects and strings by first checking them against a ruleset and then correcting them if necessary.
 """
 
+from abc import ABC
 from typing import Optional, Unpack
 
 from fabricatio.capabilities.check import Check
@@ -16,7 +17,7 @@ from fabricatio.models.kwargs_types import ReferencedKwargs
 from fabricatio.utils import override_kwargs
 
 
-class Censor(Correct, Check):
+class Censor(Correct, Check, ABC):
     """Class to censor objects and strings based on provided rulesets.
 
     Inherits from both Correct and Check classes.
@@ -46,7 +47,7 @@ class Censor(Correct, Check):
         if not imp:
             logger.info(f"No improvement found for `{obj.__class__.__name__}`.")
             return obj
-        logger.info(f'Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}')
+        logger.info(f"Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}")
         return await self.correct_obj(obj, Improvement.gather(*imp), **kwargs)
 
     async def censor_string(
@@ -72,7 +73,7 @@ class Censor(Correct, Check):
         if not imp:
             logger.info("No improvement found for string.")
             return input_text
-        logger.info(f'Generated {len(imp)} improvement(s) for string.')
+        logger.info(f"Generated {len(imp)} improvement(s) for string.")
         return await self.correct_string(input_text, Improvement.gather(*imp), **kwargs)
 
     async def censor_obj_inplace[M: ProposedUpdateAble](
@@ -100,5 +101,5 @@ class Censor(Correct, Check):
         if not imp:
             logger.info(f"No improvement found for `{obj.__class__.__name__}`.")
             return obj
-        logger.info(f'Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}')
+        logger.info(f"Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}")
         return await self.correct_obj_inplace(obj, improvement=Improvement.gather(*imp), **kwargs)