fabricatio 0.3.14.dev0__cp312-cp312-win_amd64.whl → 0.3.14.dev2__cp312-cp312-win_amd64.whl

fabricatio/__init__.py

@@ -1,22 +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 import parser
+from fabricatio import actions, capabilities, parser, toolboxes, 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, BibManager, Event
 
 __all__ = [
     "CONFIG",
     "TEMPLATE_MANAGER",
     "Action",
     "BibManager",
-    "parser",
     "Event",
     "Role",
     "Task",
@@ -26,6 +23,7 @@ __all__ = [
     "capabilities",
     "extra",
     "logger",
+    "parser",
     "toolboxes",
     "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)