fabricatio 0.3.15.dev4__cp313-cp313-win_amd64.whl → 0.4.0__cp313-cp313-win_amd64.whl

fabricatio/__init__.py

@@ -1,12 +1,14 @@
 """Fabricatio is a Python library for building llm app using event-based agent structure."""
 
-from fabricatio import actions, capabilities, fs, models, parser, toolboxes, utils, workflows
-from fabricatio.journal import logger
-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
+from fabricatio_core import fs, models, parser, utils
+from fabricatio_core.journal import logger
+from fabricatio_core.models.action import Action, WorkFlow
+from fabricatio_core.models.role import Role
+from fabricatio_core.models.task import Task
+from fabricatio_core.models.tool import ToolBox
+from fabricatio_core.rust import CONFIG, TEMPLATE_MANAGER, Event
+
+from fabricatio import actions, toolboxes, workflows
 
 __all__ = [
     "CONFIG",
@@ -18,7 +20,6 @@ __all__ = [
     "ToolBox",
     "WorkFlow",
     "actions",
-    "capabilities",
     "fs",
     "logger",
     "models",

fabricatio/actions/output.py

@@ -3,11 +3,10 @@
 from pathlib import Path
 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, FromSequence
+from fabricatio.models.generic import FinalizedDumpAble, FromMapping, FromSequence, PersistentAble
 from fabricatio.models.task import Task
 from fabricatio.models.usages import LLMUsage
 from fabricatio.rust import TEMPLATE_MANAGER
@@ -21,11 +20,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 +51,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 +90,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 +123,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 +173,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/rules.py

@@ -1,83 +1,83 @@
-"""A module containing the DraftRuleSet action."""
-
-from typing import Any, List, Mapping, Optional, Self, Tuple
-
-from fabricatio.capabilities.check import Check
-from fabricatio.journal import logger
-from fabricatio.models.action import Action
-from fabricatio.models.extra.rule import RuleSet
-from fabricatio.models.generic import FromMapping
-from fabricatio.utils import ok
-
-
-class DraftRuleSet(Action, Check, FromMapping):
-    """Action to draft a ruleset based on a given requirement description."""
-
-    output_key: str = "drafted_ruleset"
-    """The key used to store the drafted ruleset in the context dictionary."""
-
-    ruleset_requirement: Optional[str] = None
-    """The natural language description of the desired ruleset characteristics."""
-    rule_count: int = 0
-    """The number of rules to generate in the ruleset (0 for no restriction)."""
-
-    async def _execute(
-        self,
-        ruleset_requirement: Optional[str] = None,
-        **_,
-    ) -> Optional[RuleSet]:
-        """Draft a ruleset based on the requirement description.
-
-        Args:
-            ruleset_requirement (str): Natural language description of desired ruleset characteristics
-            rule_count (int): Number of rules to generate (0 for no restriction)
-            **kwargs: Validation parameters for rule generation
-
-        Returns:
-            Optional[RuleSet]: Drafted ruleset object or None if generation fails
-        """
-        ruleset = await self.draft_ruleset(
-            ruleset_requirement=ok(ruleset_requirement or self.ruleset_requirement, "No ruleset requirement provided"),
-            rule_count=self.rule_count,
-        )
-        if ruleset:
-            logger.info(f"Drafted Ruleset length: {len(ruleset.rules)}\n{ruleset.display()}")
-        else:
-            logger.warning(f"Drafting Rule Failed for:\n{ruleset_requirement}")
-        return ruleset
-
-    @classmethod
-    def from_mapping(cls, mapping: Mapping[str, Tuple[int, str]], **kwargs) -> List[Self]:
-        """Create a list of DraftRuleSet actions from a mapping of output keys to tuples of rule counts and requirements."""
-        return [cls(ruleset_requirement=r, rule_count=c, output_key=k, **kwargs) for k, (c, r) in mapping.items()]
-
-
-class GatherRuleset(Action, FromMapping):
-    """Action to gather a ruleset from a given requirement description."""
-
-    output_key: str = "gathered_ruleset"
-    """The key used to store the drafted ruleset in the context dictionary."""
-
-    to_gather: List[str]
-    """the cxt name of RuleSet to gather"""
-
-    @classmethod
-    def from_mapping(cls, mapping: Mapping[str, List[str]], **kwargs: Any) -> List[Self]:
-        """Create a list of GatherRuleset actions from a mapping of output keys to tuples of rule counts and requirements."""
-        return [cls(to_gather=t, output_key=k, **kwargs) for k, t in mapping.items()]
-
-    async def _execute(self, **cxt) -> RuleSet:
-        logger.info(f"Gathering Ruleset from {self.to_gather}")
-        # Fix for not_found
-        not_found = next((t for t in self.to_gather if t not in cxt), None)
-        if not_found:
-            raise ValueError(
-                f"Not all required keys found in context: {self.to_gather}|`{not_found}` not found in context."
-            )
-
-        # Fix for invalid RuleSet check
-        invalid = next((t for t in self.to_gather if not isinstance(cxt[t], RuleSet)), None)
-        if invalid is not None:
-            raise TypeError(f"Invalid RuleSet instance for key `{invalid}`")
-
-        return RuleSet.gather(*[cxt[t] for t in self.to_gather])
+"""A module containing the DraftRuleSet action."""
+
+from typing import Any, List, Mapping, Optional, Self, Tuple
+
+from fabricatio.capabilities.check import Check
+from fabricatio.journal import logger
+from fabricatio.models.action import Action
+from fabricatio.models.extra.rule import RuleSet
+from fabricatio.models.generic import FromMapping
+from fabricatio.utils import ok
+
+
+class DraftRuleSet(Action, Check, FromMapping):
+    """Action to draft a ruleset based on a given requirement description."""
+
+    output_key: str = "drafted_ruleset"
+    """The key used to store the drafted ruleset in the context dictionary."""
+
+    ruleset_requirement: Optional[str] = None
+    """The natural language description of the desired ruleset characteristics."""
+    rule_count: int = 0
+    """The number of rules to generate in the ruleset (0 for no restriction)."""
+
+    async def _execute(
+        self,
+        ruleset_requirement: Optional[str] = None,
+        **_,
+    ) -> Optional[RuleSet]:
+        """Draft a ruleset based on the requirement description.
+
+        Args:
+            ruleset_requirement (str): Natural language description of desired ruleset characteristics
+            rule_count (int): Number of rules to generate (0 for no restriction)
+            **kwargs: Validation parameters for rule generation
+
+        Returns:
+            Optional[RuleSet]: Drafted ruleset object or None if generation fails
+        """
+        ruleset = await self.draft_ruleset(
+            ruleset_requirement=ok(ruleset_requirement or self.ruleset_requirement, "No ruleset requirement provided"),
+            rule_count=self.rule_count,
+        )
+        if ruleset:
+            logger.info(f"Drafted Ruleset length: {len(ruleset.rules)}\n{ruleset.display()}")
+        else:
+            logger.warning(f"Drafting Rule Failed for:\n{ruleset_requirement}")
+        return ruleset
+
+    @classmethod
+    def from_mapping(cls, mapping: Mapping[str, Tuple[int, str]], **kwargs) -> List[Self]:
+        """Create a list of DraftRuleSet actions from a mapping of output keys to tuples of rule counts and requirements."""
+        return [cls(ruleset_requirement=r, rule_count=c, output_key=k, **kwargs) for k, (c, r) in mapping.items()]
+
+
+class GatherRuleset(Action, FromMapping):
+    """Action to gather a ruleset from a given requirement description."""
+
+    output_key: str = "gathered_ruleset"
+    """The key used to store the drafted ruleset in the context dictionary."""
+
+    to_gather: List[str]
+    """the cxt name of RuleSet to gather"""
+
+    @classmethod
+    def from_mapping(cls, mapping: Mapping[str, List[str]], **kwargs: Any) -> List[Self]:
+        """Create a list of GatherRuleset actions from a mapping of output keys to tuples of rule counts and requirements."""
+        return [cls(to_gather=t, output_key=k, **kwargs) for k, t in mapping.items()]
+
+    async def _execute(self, **cxt) -> RuleSet:
+        logger.info(f"Gathering Ruleset from {self.to_gather}")
+        # Fix for not_found
+        not_found = next((t for t in self.to_gather if t not in cxt), None)
+        if not_found:
+            raise ValueError(
+                f"Not all required keys found in context: {self.to_gather}|`{not_found}` not found in context."
+            )
+
+        # Fix for invalid RuleSet check
+        invalid = next((t for t in self.to_gather if not isinstance(cxt[t], RuleSet)), None)
+        if invalid is not None:
+            raise TypeError(f"Invalid RuleSet instance for key `{invalid}`")
+
+        return RuleSet.gather(*[cxt[t] for t in self.to_gather])

fabricatio/workflows/rag.py

@@ -1,8 +1,9 @@
 """The workflow for extracting the essence of an article and storing it in the database."""
 
+from fabricatio_core.models.action import WorkFlow
+
 from fabricatio.actions.article import ExtractArticleEssence
 from fabricatio.actions.rag import InjectToDB
-from fabricatio.models.action import WorkFlow
 
 StoreArticle = WorkFlow(
     name="Extract Article Essence",

{fabricatio-0.3.15.dev4.dist-info → fabricatio-0.4.0.dist-info}/METADATA

@@ -1,33 +1,32 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.3.15.dev4
+Version: 0.4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Framework :: AsyncIO
 Classifier: Framework :: Pydantic :: 2
 Classifier: Typing :: Typed
-Requires-Dist: asyncio>=3.4.3
-Requires-Dist: asyncstdlib>=3.13.0
-Requires-Dist: json-repair>=0.39.1
-Requires-Dist: litellm>=1.60.0
-Requires-Dist: loguru>=0.7.3
-Requires-Dist: more-itertools>=10.6.0
-Requires-Dist: pydantic>=2.10.6
-Requires-Dist: pymitter>=1.0.0
-Requires-Dist: rich>=13.9.4
-Requires-Dist: ujson>=5.10.0
-Requires-Dist: fabricatio[ftd,qa,rag,cli] ; extra == 'full'
-Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
+Requires-Dist: fabricatio-core
+Requires-Dist: fabricatio-capabilities
+Requires-Dist: fabricatio[ftd,qa,rag,cli,typst,rule,judge] ; extra == 'full'
+Requires-Dist: fabricatio-rag ; extra == 'rag'
+Requires-Dist: fabricatio-judge ; extra == 'judge'
+Requires-Dist: fabricatio-rule ; extra == 'rule'
 Requires-Dist: questionary>=2.1.0 ; extra == 'qa'
 Requires-Dist: magika>=0.6.1 ; extra == 'ftd'
 Requires-Dist: typer-slim[standard]>=0.15.2 ; extra == 'cli'
+Requires-Dist: fabricatio-typst ; extra == 'typst'
 Provides-Extra: full
 Provides-Extra: rag
+Provides-Extra: judge
+Provides-Extra: rule
 Provides-Extra: qa
 Provides-Extra: ftd
 Provides-Extra: cli
+Provides-Extra: typst
 License-File: LICENSE
 Summary: A LLM multi-agent framework.
 Keywords: ai,agents,multi-agent,llm,pyo3
@@ -65,8 +64,11 @@ pip install uv
 git clone https://github.com/Whth/fabricatio.git
 cd fabricatio
 
-# Install the package in development mode with uv
-uv --with-editable . maturin develop --uv -r
+# Install the package in development mode with uvx
+uvx --with-editable . maturin develop --uv -r
+
+# Or, with make
+make dev
 ```
 
 ### Building Distribution
@@ -153,7 +155,7 @@ max_tokens = 8192
     ```
 2. **Install Dependencies**:
     ```bash
-    uv --with-editable . maturin develop --uv -r
+    make dev
     ```
 3. **Run Tests**:
     ```bash

fabricatio-0.4.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+fabricatio-0.4.0.data/scripts/tdown.exe,sha256=wJB4uqkaC7lj5SdJTbsBoa6Cz-Bl_WC-jnZeabGwfic,3378176
+fabricatio-0.4.0.dist-info/METADATA,sha256=f0SYcL4jgeWa4X3giEG6zJZ6qXActgZQ0ynZuJXO2ds,5189
+fabricatio-0.4.0.dist-info/WHEEL,sha256=Fk195VgSS-LCRRJAxz6O39eu2NdDhBCq3h9q4zoTguY,96
+fabricatio-0.4.0.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/__init__.py,sha256=9YbjjPgR_-rvuXt86oNLXZodDm3zltnMNmhP-1pESvE,786
+fabricatio/actions/__init__.py,sha256=wVENCFtpVb1rLFxoOFJt9-8smLWXuJV7IwA8P3EfFz4,48
+fabricatio/actions/fs.py,sha256=gJR14U4ln35nt8Z7OWLVAZpqGaLnED-r1Yi-lX22tkI,959
+fabricatio/actions/output.py,sha256=nYKCUkNyAVziJmKS_Hdxnb015CrHRFdLJuQJlkEyB1s,9971
+fabricatio/actions/rag.py,sha256=vgCzIfbSd3_vL3QxB12PY4h12V9Pe3sZRsWme0KC6X8,3583
+fabricatio/actions/rules.py,sha256=07ILsiwR250AUcKLPHTUPpWD_mPhPCfWKSkEAKcPv3A,3557
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/rust.cp313-win_amd64.pyd,sha256=L-c7Su6i5T4fqbGfJU8pqQW5Vx4kaDM1gvidnlFmp9g,176128
+fabricatio/toolboxes/__init__.py,sha256=KBJi5OG_pExscdlM7Bnt_UF43j4I3Lv6G71kPVu4KQU,395
+fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
+fabricatio/toolboxes/fs.py,sha256=l4L1CVxJmjw9Ld2XUpIlWfV0_Fu_2Og6d3E13I-S4aE,736
+fabricatio/workflows/__init__.py,sha256=5ScFSTA-bvhCesj3U9Mnmi6Law6N1fmh5UKyh58L3u8,51
+fabricatio/workflows/rag.py,sha256=O8qCLhZTJTEj72R7W6Nq3WFg2I42arzQJkIGaeDdpss,527
+fabricatio-0.4.0.dist-info/RECORD,,