fabricatio 0.4.0__cp313-cp313-win_amd64.whl → 0.4.0.dev0__cp313-cp313-win_amd64.whl

fabricatio/__init__.py

@@ -1,5 +1,6 @@
 """Fabricatio is a Python library for building llm app using event-based agent structure."""
 
+from fabricatio import toolboxes, workflows
 from fabricatio_core import fs, models, parser, utils
 from fabricatio_core.journal import logger
 from fabricatio_core.models.action import Action, WorkFlow
@@ -8,8 +9,6 @@ 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",
     "TEMPLATE_MANAGER",
@@ -19,7 +18,6 @@ __all__ = [
     "Task",
     "ToolBox",
     "WorkFlow",
-    "actions",
     "fs",
     "logger",
     "models",

fabricatio/toolboxes/arithmetic.py

@@ -1,6 +1,6 @@
 """Arithmetic tools for Fabricatio."""
 
-from fabricatio.models.tool import ToolBox
+from fabricatio_core.models.tool import ToolBox
 
 arithmetic_toolbox = ToolBox(name="ArithmeticToolBox", description="A toolbox for arithmetic operations.")
 

fabricatio/toolboxes/fs.py

@@ -1,6 +1,6 @@
 """File system tool box."""
 
-from fabricatio.fs import (
+from fabricatio_core.fs import (
     absolute_path,
     copy_file,
     create_directory,
@@ -13,7 +13,7 @@ from fabricatio.fs import (
     safe_text_read,
     tree,
 )
-from fabricatio.models.tool import ToolBox
+from fabricatio_core.models.tool import ToolBox
 
 fs_toolbox = (
     ToolBox(name="FsToolBox", description="A toolbox for basic file system operations.")

{fabricatio-0.4.0.dist-info → fabricatio-0.4.0.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.4.0
+Version: 0.4.0.dev0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -10,8 +10,7 @@ Classifier: Framework :: AsyncIO
 Classifier: Framework :: Pydantic :: 2
 Classifier: Typing :: Typed
 Requires-Dist: fabricatio-core
-Requires-Dist: fabricatio-capabilities
-Requires-Dist: fabricatio[ftd,qa,rag,cli,typst,rule,judge] ; extra == 'full'
+Requires-Dist: fabricatio[ftd,qa,rag,cli,typst,rule,judge,capabilities,actions] ; extra == 'full'
 Requires-Dist: fabricatio-rag ; extra == 'rag'
 Requires-Dist: fabricatio-judge ; extra == 'judge'
 Requires-Dist: fabricatio-rule ; extra == 'rule'
@@ -19,6 +18,9 @@ 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'
+Requires-Dist: fabricatio-improve ; extra == 'improve'
+Requires-Dist: fabricatio-capabilities ; extra == 'capabilities'
+Requires-Dist: fabricatio-actions ; extra == 'actions'
 Provides-Extra: full
 Provides-Extra: rag
 Provides-Extra: judge
@@ -27,6 +29,9 @@ Provides-Extra: qa
 Provides-Extra: ftd
 Provides-Extra: cli
 Provides-Extra: typst
+Provides-Extra: improve
+Provides-Extra: capabilities
+Provides-Extra: actions
 License-File: LICENSE
 Summary: A LLM multi-agent framework.
 Keywords: ai,agents,multi-agent,llm,pyo3

fabricatio-0.4.0.dev0.dist-info/RECORD

@@ -0,0 +1,13 @@
+fabricatio-0.4.0.dev0.data/scripts/tdown.exe,sha256=CknuR-ux_D0TLfFPS5ciBdsheg4cbiJAV9BjoRm_w1s,3378176
+fabricatio-0.4.0.dev0.dist-info/METADATA,sha256=e2CWOqor1_NCKIPX0iLwzs_PU5sDOg-vgssE03c8Adw,5428
+fabricatio-0.4.0.dev0.dist-info/WHEEL,sha256=Fk195VgSS-LCRRJAxz6O39eu2NdDhBCq3h9q4zoTguY,96
+fabricatio-0.4.0.dev0.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/__init__.py,sha256=lRDjxg_ZZwE9GTASwUOuHc6asov0JRJHJ4PqI2rph_g,759
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/rust.cp313-win_amd64.pyd,sha256=jlL8yq1Uk8ApCYOFFlfwDZpGHl7Num2V-KIJwW5PuVY,176128
+fabricatio/toolboxes/__init__.py,sha256=KBJi5OG_pExscdlM7Bnt_UF43j4I3Lv6G71kPVu4KQU,395
+fabricatio/toolboxes/arithmetic.py,sha256=tcaHLzGQvnlbxG57IANpZ2vTRO5QpSt366RckBlBIOg,1374
+fabricatio/toolboxes/fs.py,sha256=fpSfU6YkCVJzSXsbT9WT3m80tH8i6mhLWnu9u7yhV-w,746
+fabricatio/workflows/__init__.py,sha256=5ScFSTA-bvhCesj3U9Mnmi6Law6N1fmh5UKyh58L3u8,51
+fabricatio/workflows/rag.py,sha256=O8qCLhZTJTEj72R7W6Nq3WFg2I42arzQJkIGaeDdpss,527
+fabricatio-0.4.0.dev0.dist-info/RECORD,,

fabricatio/actions/__init__.py

@@ -1 +0,0 @@
-"""A module containing some builtin actins."""

fabricatio/actions/fs.py

@@ -1,25 +0,0 @@
-"""A module for file system utilities."""
-
-from pathlib import Path
-from typing import Any, List, Mapping, Self
-
-from fabricatio.fs import safe_text_read
-from fabricatio.journal import logger
-from fabricatio.models.action import Action
-from fabricatio.models.generic import FromMapping
-
-
-class ReadText(Action, FromMapping):
-    """Read text from a file."""
-    output_key: str = "read_text"
-    read_path: str | Path
-    """Path to the file to read."""
-
-    async def _execute(self, *_: Any, **cxt) -> str:
-        logger.info(f"Read text from {Path(self.read_path).as_posix()} to {self.output_key}")
-        return safe_text_read(self.read_path)
-
-    @classmethod
-    def from_mapping(cls, mapping: Mapping[str, str | Path], **kwargs: Any) -> List[Self]:
-        """Create a list of ReadText actions from a mapping of output_key to read_path."""
-        return [cls(read_path=p, output_key=k, **kwargs) for k, p in mapping.items()]

fabricatio/actions/output.py

@@ -1,247 +0,0 @@
-"""Dump the finalized output to a file."""
-
-from pathlib import Path
-from typing import Any, Iterable, List, Mapping, Optional, Self, Sequence, Type
-
-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, PersistentAble
-from fabricatio.models.task import Task
-from fabricatio.models.usages import LLMUsage
-from fabricatio.rust import TEMPLATE_MANAGER
-from fabricatio.utils import ok
-
-
-class DumpFinalizedOutput(Action, LLMUsage):
-    """Dump the finalized output to a file."""
-
-    output_key: str = "dump_path"
-    dump_path: Optional[str] = None
-
-    async def _execute(
-            self,
-            to_dump: FinalizedDumpAble,
-            task_input: Optional[Task] = None,
-            dump_path: Optional[str | Path] = None,
-            **_,
-    ) -> str:
-        dump_path = Path(
-            dump_path
-            or self.dump_path
-            or ok(
-                await self.awhich_pathstr(
-                    f"{ok(task_input, 'Neither `task_input` and `dump_path` is provided.').briefing}\n\nExtract a single path of the file, to which I will dump the data."
-                ),
-                "Could not find the path of file to dump the data.",
-            )
-        )
-        logger.info(f"Saving output to {dump_path.as_posix()}")
-        ok(to_dump, "Could not dump the data since the path is not specified.").finalized_dump_to(dump_path)
-        return dump_path.as_posix()
-
-
-class RenderedDump(Action, LLMUsage):
-    """Render the data to a file."""
-
-    output_key: str = "dump_path"
-    dump_path: Optional[str] = None
-
-    template_name: str
-    """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,
-            **_,
-    ) -> str:
-        dump_path = Path(
-            dump_path
-            or self.dump_path
-            or ok(
-                await self.awhich_pathstr(
-                    f"{ok(task_input, 'Neither `task_input` and `dump_path` is provided.').briefing}\n\nExtract a single path of the file, to which I will dump the data."
-                ),
-                "Could not find the path of file to dump the data.",
-            )
-        )
-
-        logger.info(f"Saving output to {dump_path.as_posix()}")
-        dump_text(
-            dump_path,
-            TEMPLATE_MANAGER.render_template(
-                self.template_name, {to_dump.__class__.__name__: to_dump.finalized_dump()}
-            ),
-        )
-
-        return dump_path.as_posix()
-
-
-class PersistentAll(Action, LLMUsage):
-    """Persist all the data to a file."""
-
-    output_key: str = "persistent_count"
-    """The number of objects persisted."""
-    persist_dir: Optional[str] = None
-    """The directory to persist the data."""
-    override: bool = False
-    """Whether to remove the existing dir before dumping."""
-
-    async def _execute(
-            self,
-            task_input: Optional[Task] = None,
-            persist_dir: Optional[str | Path] = None,
-            **cxt,
-    ) -> int:
-        persist_dir = Path(
-            persist_dir
-            or self.persist_dir
-            or ok(
-                await self.awhich_pathstr(
-                    f"{ok(task_input, 'Neither `task_input` and `dump_path` is provided.').briefing}\n\nExtract a single path of the file, to which I will persist the data."
-                ),
-                "Can not find the path of file to persist the data.",
-            )
-        )
-
-        count = 0
-        if persist_dir.is_file():
-            logger.warning("Dump should be a directory, but it is a file. Skip dumping.")
-            return count
-        if self.override and persist_dir.is_dir():
-            logger.info(f"Override the existing directory {persist_dir.as_posix()}.")
-            persist_dir.rmdir()
-        logger.info(f"Starting persistence in directory {persist_dir}")
-        for k, v in cxt.items():
-            final_dir = persist_dir.joinpath(k)
-            logger.debug(f"Checking key {k} for persistence")
-            if isinstance(v, PersistentAble):
-                logger.info(f"Persisting object {k} to {final_dir}")
-                final_dir.mkdir(parents=True, exist_ok=True)
-                v.persist(final_dir)
-                count += 1
-            if isinstance(v, Iterable) and any(
-                    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)
-                for per in persistent_ables:
-                    per.persist(final_dir)
-                    count += 1
-        logger.info(f"Persisted {count} objects to {persist_dir}")
-        return count
-
-
-class RetrieveFromPersistent[T: PersistentAble](Action):
-    """Retrieve the object from the persistent file."""
-
-    output_key: str = "retrieved_obj"
-    """Retrieve the object from the persistent file."""
-    load_path: str
-    """The path of the persistent file or directory contains multiple file."""
-    retrieve_cls: Type[T]
-    """The class of the object to retrieve."""
-
-    async def _execute(self, /, **_) -> Optional[T | List[T]]:
-        logger.info(f"Retrieve `{self.retrieve_cls.__name__}` from {self.load_path}")
-        if not (p := Path(self.load_path)).exists():
-            logger.warning(f"Path {self.load_path} does not exist")
-            return None
-
-        if p.is_dir():
-            logger.info(f"Found directory with {len(list(p.glob('*')))} items")
-            return [self.retrieve_cls.from_persistent(per) for per in p.glob("*")]
-        return self.retrieve_cls.from_persistent(self.load_path)
-
-
-class RetrieveFromLatest[T: PersistentAble](RetrieveFromPersistent[T], FromMapping):
-    """Retrieve the object from the latest persistent file in the dir at `load_path`."""
-
-    async def _execute(self, /, **_) -> Optional[T]:
-        logger.info(f"Retrieve latest `{self.retrieve_cls.__name__}` from {self.load_path}")
-        if not (p := Path(self.load_path)).exists():
-            logger.warning(f"Path {self.load_path} does not exist")
-            return None
-
-        if p.is_dir():
-            logger.info(f"Found directory with {len(list(p.glob('*')))} items")
-            return self.retrieve_cls.from_latest_persistent(self.load_path)
-        logger.error(f"Path {self.load_path} is not a directory")
-        return None
-
-    @classmethod
-    def from_mapping(
-            cls,
-            mapping: Mapping[str, str | Path],
-            *,
-            retrieve_cls: Type[T],
-            **kwargs,
-    ) -> List["RetrieveFromLatest[T]"]:
-        """Create a list of `RetrieveFromLatest` from the mapping."""
-        return [
-            cls(retrieve_cls=retrieve_cls, load_path=Path(p).as_posix(), output_key=o, **kwargs)
-            for o, p in mapping.items()
-        ]
-
-
-class GatherAsList(Action):
-    """Gather the objects from the context as a list.
-
-    Notes:
-        If both `gather_suffix` and `gather_prefix` are specified, only the objects with the suffix will be gathered.
-    """
-
-    output_key: str = "gathered"
-    """Gather the objects from the context as a list."""
-    gather_suffix: Optional[str] = None
-    """Gather the objects from the context as a list."""
-    gather_prefix: Optional[str] = None
-    """Gather the objects from the context as a list."""
-
-    async def _execute(self, **cxt) -> List[Any]:
-        if self.gather_suffix is not None:
-            result = [cxt[k] for k in cxt if k.endswith(self.gather_suffix)]
-            logger.debug(f"Gathered {len(result)} items with suffix {self.gather_suffix}")
-            return result
-        if self.gather_prefix is None:
-            logger.error(err := "Either `gather_suffix` or `gather_prefix` must be specified.")
-            raise ValueError(err)
-        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

@@ -1,96 +0,0 @@
-"""Inject data into the database."""
-
-from typing import List, Optional
-
-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
-
-
-class InjectToDB(Action, RAG):
-    """Inject data into the database."""
-
-    output_key: str = "collection_name"
-    collection_name: str = "my_collection"
-    """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, **_
-    ) -> Optional[str]:
-        from pymilvus.milvus_client import IndexParams
-
-        if to_inject is None:
-            return None
-        if not isinstance(to_inject, list):
-            to_inject = [to_inject]
-        if not (seq := [t for t in to_inject if t is not None]):  # filter out None
-            return None
-        logger.info(f"Injecting {len(seq)} items into the collection '{self.collection_name}'")
-        if override_inject:
-            self.check_client().client.drop_collection(self.collection_name)
-
-        await self.view(
-            self.collection_name,
-            create=True,
-            schema=seq[0].as_milvus_schema(
-                ok(
-                    self.milvus_dimensions
-                    or CONFIG.rag.milvus_dimensions
-                    or self.embedding_dimensions
-                    or CONFIG.embedding.dimensions
-                ),
-            ),
-            index_params=IndexParams(
-                seq[0].vector_field_name,
-                index_name=seq[0].vector_field_name,
-                index_type=seq[0].index_type,
-                metric_type=seq[0].metric_type,
-            ),
-        ).add_document(seq, flush=True)
-
-        return self.collection_name
-
-
-class RAGTalk(Action, RAG):
-    """RAG-enabled conversational action that processes user questions based on a given task.
-
-    This action establishes an interactive conversation loop where it retrieves context-relevant
-    information to answer user queries according to the assigned task briefing.
-
-    Notes:
-        task_input: Task briefing that guides how to respond to user questions
-        collection_name: Name of the vector collection to use for retrieval (default: "my_collection")
-
-    Returns:
-        Number of conversation turns completed before termination
-    """
-
-    output_key: str = "task_output"
-
-    async def _execute(self, task_input: Task[str], **kwargs) -> int:
-        from questionary import text
-
-        collection_name = kwargs.get("collection_name", "my_collection")
-        counter = 0
-
-        self.view(collection_name, create=True)
-
-        try:
-            while True:
-                user_say = await text("User: ").ask_async()
-                if user_say is None:
-                    break
-                ret: List[MilvusClassicModel] = await self.aretrieve(user_say, document_model=MilvusClassicModel)
-
-                gpt_say = await self.aask(
-                    user_say, system_message="\n".join(m.text for m in ret) + "\nYou can refer facts provided above."
-                )
-                print(f"GPT: {gpt_say}")  # noqa: T201
-                counter += 1
-        except KeyboardInterrupt:
-            logger.info(f"executed talk action {counter} times")
-        return counter

fabricatio/actions/rules.py

@@ -1,83 +0,0 @@
-"""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-0.4.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-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,,