fabricatio 0.2.0.dev14__cp312-cp312-win_amd64.whl → 0.2.0.dev17__cp312-cp312-win_amd64.whl

fabricatio/models/usages.py

@@ -0,0 +1,464 @@
+"""This module contains classes that manage the usage of language models and tools in tasks."""
+
+from typing import Callable, Dict, Iterable, List, NotRequired, Optional, Self, Set, TypedDict, Union, Unpack
+
+import litellm
+import orjson
+from fabricatio._rust_instances import template_manager
+from fabricatio.config import configs
+from fabricatio.journal import logger
+from fabricatio.models.generic import Base, WithBriefing
+from fabricatio.models.task import Task
+from fabricatio.models.tool import Tool, ToolBox
+from fabricatio.models.utils import Messages
+from fabricatio.parser import JsonCapture
+from litellm.types.utils import Choices, ModelResponse, StreamingChoices
+from pydantic import Field, HttpUrl, NonNegativeFloat, NonNegativeInt, PositiveInt, SecretStr
+
+
+class LLMKwargs(TypedDict):
+    """A type representing the keyword arguments for the LLM (Large Language Model) usage."""
+
+    model: NotRequired[str]
+    temperature: NotRequired[NonNegativeFloat]
+    stop: NotRequired[str | List[str]]
+    top_p: NotRequired[NonNegativeFloat]
+    max_tokens: NotRequired[PositiveInt]
+    stream: NotRequired[bool]
+    timeout: NotRequired[PositiveInt]
+    max_retries: NotRequired[PositiveInt]
+
+
+class LLMUsage(Base):
+    """Class that manages LLM (Large Language Model) usage parameters and methods."""
+
+    llm_api_endpoint: Optional[HttpUrl] = None
+    """The OpenAI API endpoint."""
+
+    llm_api_key: Optional[SecretStr] = None
+    """The OpenAI API key."""
+
+    llm_timeout: Optional[PositiveInt] = None
+    """The timeout of the LLM model."""
+
+    llm_max_retries: Optional[PositiveInt] = None
+    """The maximum number of retries."""
+
+    llm_model: Optional[str] = None
+    """The LLM model name."""
+
+    llm_temperature: Optional[NonNegativeFloat] = None
+    """The temperature of the LLM model."""
+
+    llm_stop_sign: Optional[str | List[str]] = None
+    """The stop sign of the LLM model."""
+
+    llm_top_p: Optional[NonNegativeFloat] = None
+    """The top p of the LLM model."""
+
+    llm_generation_count: Optional[PositiveInt] = None
+    """The number of generations to generate."""
+
+    llm_stream: Optional[bool] = None
+    """Whether to stream the LLM model's response."""
+
+    llm_max_tokens: Optional[PositiveInt] = None
+    """The maximum number of tokens to generate."""
+
+    async def aquery(
+        self,
+        messages: List[Dict[str, str]],
+        n: PositiveInt | None = None,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> ModelResponse:
+        """Asynchronously queries the language model to generate a response based on the provided messages and parameters.
+
+        Args:
+            messages (List[Dict[str, str]]): A list of messages, where each message is a dictionary containing the role and content of the message.
+            n (PositiveInt | None): The number of responses to generate. Defaults to the instance's `llm_generation_count` or the global configuration.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            ModelResponse: An object containing the generated response and other metadata from the model.
+        """
+        # Call the underlying asynchronous completion function with the provided and default parameters
+        return await litellm.acompletion(
+            messages=messages,
+            n=n or self.llm_generation_count or configs.llm.generation_count,
+            model=kwargs.get("model") or self.llm_model or configs.llm.model,
+            temperature=kwargs.get("temperature") or self.llm_temperature or configs.llm.temperature,
+            stop=kwargs.get("stop") or self.llm_stop_sign or configs.llm.stop_sign,
+            top_p=kwargs.get("top_p") or self.llm_top_p or configs.llm.top_p,
+            max_tokens=kwargs.get("max_tokens") or self.llm_max_tokens or configs.llm.max_tokens,
+            stream=kwargs.get("stream") or self.llm_stream or configs.llm.stream,
+            timeout=kwargs.get("timeout") or self.llm_timeout or configs.llm.timeout,
+            max_retries=kwargs.get("max_retries") or self.llm_max_retries or configs.llm.max_retries,
+            api_key=self.llm_api_key.get_secret_value() if self.llm_api_key else configs.llm.api_key.get_secret_value(),
+            base_url=self.llm_api_endpoint.unicode_string()
+            if self.llm_api_endpoint
+            else configs.llm.api_endpoint.unicode_string(),
+        )
+
+    async def ainvoke(
+        self,
+        question: str,
+        system_message: str = "",
+        n: PositiveInt | None = None,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> List[Choices | StreamingChoices]:
+        """Asynchronously invokes the language model with a question and optional system message.
+
+        Args:
+            question (str): The question to ask the model.
+            system_message (str): The system message to provide context to the model. Defaults to an empty string.
+            n (PositiveInt | None): The number of responses to generate. Defaults to the instance's `llm_generation_count` or the global configuration.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            List[Choices | StreamingChoices]: A list of choices or streaming choices from the model response.
+        """
+        return (
+            await self.aquery(
+                messages=Messages().add_system_message(system_message).add_user_message(question),
+                n=n,
+                **kwargs,
+            )
+        ).choices
+
+    async def aask(
+        self,
+        question: str,
+        system_message: str = "",
+        **kwargs: Unpack[LLMKwargs],
+    ) -> str:
+        """Asynchronously asks the language model a question and returns the response content.
+
+        Args:
+            question (str): The question to ask the model.
+            system_message (str): The system message to provide context to the model. Defaults to an empty string.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            str: The content of the model's response message.
+        """
+        return (
+            (
+                await self.ainvoke(
+                    n=1,
+                    question=question,
+                    system_message=system_message,
+                    **kwargs,
+                )
+            )
+            .pop()
+            .message.content
+        )
+
+    async def aask_validate[T](
+        self,
+        question: str,
+        validator: Callable[[str], T | None],
+        max_validations: PositiveInt = 2,
+        system_message: str = "",
+        **kwargs: Unpack[LLMKwargs],
+    ) -> T:
+        """Asynchronously asks a question and validates the response using a given validator.
+
+        Args:
+            question (str): The question to ask.
+            validator (Callable[[str], T | None]): A function to validate the response.
+            max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 2.
+            system_message (str): System message to include in the request. Defaults to an empty string.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            T: The validated response.
+
+        Raises:
+            ValueError: If the response fails to validate after the maximum number of attempts.
+        """
+        for _ in range(max_validations):
+            if (
+                response := await self.aask(
+                    question=question,
+                    system_message=system_message,
+                    **kwargs,
+                )
+            ) and (validated := validator(response)):
+                return validated
+        raise ValueError("Failed to validate the response.")
+
+    async def achoose[T: WithBriefing](
+        self,
+        instruction: str,
+        choices: List[T],
+        k: NonNegativeInt = 0,
+        max_validations: PositiveInt = 2,
+        system_message: str = "",
+        **kwargs: Unpack[LLMKwargs],
+    ) -> List[T]:
+        """Asynchronously executes a multi-choice decision-making process, generating a prompt based on the instruction and options, and validates the returned selection results.
+
+        Args:
+            instruction (str): The user-provided instruction/question description.
+            choices (List[T]): A list of candidate options, requiring elements to have `name` and `briefing` fields.
+            k (NonNegativeInt): The number of choices to select, 0 means infinite. Defaults to 0.
+            max_validations (PositiveInt): Maximum number of validation failures, default is 2.
+            system_message (str): Custom system-level prompt, defaults to an empty string.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            List[T]: The final validated selection result list, with element types matching the input `choices`.
+
+        Important:
+            - Uses a template engine to generate structured prompts.
+            - Ensures response compliance through JSON parsing and format validation.
+            - Relies on `aask_validate` to implement retry mechanisms with validation.
+        """
+        prompt = template_manager.render_template(
+            "make_choice",
+            {
+                "instruction": instruction,
+                "options": [m.model_dump(include={"name", "briefing"}) for m in choices],
+                "k": k,
+            },
+        )
+        names = [c.name for c in choices]
+
+        def _validate(response: str) -> List[T] | None:
+            ret = JsonCapture.convert_with(response, orjson.loads)
+            if not isinstance(ret, List) or len(ret) != k:
+                return None
+            if any(n not in names for n in ret):
+                return None
+            return ret
+
+        return await self.aask_validate(
+            question=prompt,
+            validator=_validate,
+            max_validations=max_validations,
+            system_message=system_message,
+            **kwargs,
+        )
+
+    async def ajudge(
+        self,
+        prompt: str,
+        affirm_case: str = "",
+        deny_case: str = "",
+        max_validations: PositiveInt = 2,
+        system_message: str = "",
+        **kwargs: Unpack[LLMKwargs],
+    ) -> bool:
+        """Asynchronously judges a prompt using AI validation.
+
+        Args:
+            prompt (str): The input prompt to be judged.
+            affirm_case (str): The affirmative case for the AI model. Defaults to an empty string.
+            deny_case (str): The negative case for the AI model. Defaults to an empty string.
+            max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 2.
+            system_message (str): System message for the AI model. Defaults to an empty string.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            bool: The judgment result (True or False) based on the AI's response.
+
+        Notes:
+            The method uses an internal validator to ensure the response is a boolean value.
+            If the response cannot be converted to a boolean, it will return None.
+        """
+
+        def _validate(response: str) -> bool | None:
+            ret = JsonCapture.convert_with(response, orjson.loads)
+            if not isinstance(ret, bool):
+                return None
+            return ret
+
+        return await self.aask_validate(
+            question=template_manager.render_template(
+                "make_judgment", {"prompt": prompt, "affirm_case": affirm_case, "deny_case": deny_case}
+            ),
+            validator=_validate,
+            max_validations=max_validations,
+            system_message=system_message,
+            **kwargs,
+        )
+
+    def fallback_to(self, other: "LLMUsage") -> Self:
+        """Fallback to another instance's attribute values if the current instance's attributes are None.
+
+        Args:
+            other (LLMUsage): Another instance from which to copy attribute values.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        # Iterate over the attribute names and copy values from 'other' to 'self' where applicable
+        # noinspection PydanticTypeChecker,PyTypeChecker
+        for attr_name in LLMUsage.model_fields:
+            # Copy the attribute value from 'other' to 'self' only if 'self' has None and 'other' has a non-None value
+            if getattr(self, attr_name) is None and (attr := getattr(other, attr_name)) is not None:
+                setattr(self, attr_name, attr)
+
+        # Return the current instance to allow for method chaining
+        return self
+
+    def hold_to(self, others: Union["LLMUsage", Iterable["LLMUsage"]]) -> Self:
+        """Hold to another instance's attribute values if the current instance's attributes are None.
+
+        Args:
+            others (LLMUsage | Iterable[LLMUsage]): Another instance or iterable of instances from which to copy attribute values.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        for other in others:
+            # noinspection PyTypeChecker,PydanticTypeChecker
+            for attr_name in LLMUsage.model_fields:
+                if (attr := getattr(self, attr_name)) is not None and getattr(other, attr_name) is None:
+                    setattr(other, attr_name, attr)
+
+
+class ChooseKwargs(LLMKwargs):
+    """A type representing the keyword arguments for the choose method."""
+
+    max_validations: NotRequired[PositiveInt]
+    system_message: NotRequired[str]
+    k: NotRequired[NonNegativeInt]
+
+
+class ToolBoxUsage(LLMUsage):
+    """A class representing the usage of tools in a task."""
+
+    toolboxes: Set[ToolBox] = Field(default_factory=set)
+    """A set of toolboxes used by the instance."""
+
+    @property
+    def available_toolbox_names(self) -> List[str]:
+        """Return a list of available toolbox names."""
+        return [toolbox.name for toolbox in self.toolboxes]
+
+    async def choose_toolboxes(
+        self,
+        task: Task,
+        system_message: str = "",
+        k: NonNegativeInt = 0,
+        max_validations: PositiveInt = 2,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> List[ToolBox]:
+        """Asynchronously executes a multi-choice decision-making process to choose toolboxes.
+
+        Args:
+            task (Task): The task for which to choose toolboxes.
+            system_message (str): Custom system-level prompt, defaults to an empty string.
+            k (NonNegativeInt): The number of toolboxes to select, 0 means infinite. Defaults to 0.
+            max_validations (PositiveInt): Maximum number of validation failures, default is 2.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            List[ToolBox]: The selected toolboxes.
+        """
+        if not self.toolboxes:
+            logger.warning("No toolboxes available.")
+            return []
+        return await self.achoose(
+            instruction=task.briefing,
+            choices=list(self.toolboxes),
+            k=k,
+            max_validations=max_validations,
+            system_message=system_message,
+            **kwargs,
+        )
+
+    async def choose_tools(
+        self,
+        task: Task,
+        toolbox: ToolBox,
+        system_message: str = "",
+        k: NonNegativeInt = 0,
+        max_validations: PositiveInt = 2,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> List[Tool]:
+        """Asynchronously executes a multi-choice decision-making process to choose tools.
+
+        Args:
+            task (Task): The task for which to choose tools.
+            toolbox (ToolBox): The toolbox from which to choose tools.
+            system_message (str): Custom system-level prompt, defaults to an empty string.
+            k (NonNegativeInt): The number of tools to select, 0 means infinite. Defaults to 0.
+            max_validations (PositiveInt): Maximum number of validation failures, default is 2.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            List[Tool]: The selected tools.
+        """
+        if not toolbox.tools:
+            logger.warning(f"No tools available in toolbox {toolbox.name}.")
+            return []
+        return await self.achoose(
+            instruction=task.briefing,
+            choices=toolbox.tools,
+            k=k,
+            max_validations=max_validations,
+            system_message=system_message,
+            **kwargs,
+        )
+
+    async def gather_tools(
+        self,
+        task: Task,
+        box_choose_kwargs: Optional[ChooseKwargs] = None,
+        tool_choose_kwargs: Optional[ChooseKwargs] = None,
+    ) -> List[Tool]:
+        """Asynchronously gathers tools based on the provided task and toolbox and tool selection criteria.
+
+        Args:
+            task (Task): The task for which to gather tools.
+            box_choose_kwargs (Optional[ChooseKwargs]): Keyword arguments for choosing toolboxes, such as `system_message`, `k`, `max_validations`, `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+            tool_choose_kwargs (Optional[ChooseKwargs]): Keyword arguments for choosing tools, such as `system_message`, `k`, `max_validations`, `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            List[Tool]: A list of tools gathered based on the provided task and toolbox and tool selection criteria.
+        """
+        box_choose_kwargs = box_choose_kwargs or {}
+        tool_choose_kwargs = tool_choose_kwargs or {}
+
+        # Choose the toolboxes
+        chosen_toolboxes = await self.choose_toolboxes(task, **box_choose_kwargs)
+        # Choose the tools
+        chosen_tools = []
+        for toolbox in chosen_toolboxes:
+            chosen_tools.extend(await self.choose_tools(task, toolbox, **tool_choose_kwargs))
+        return chosen_tools
+
+    def supply_tools_from[S: "ToolBoxUsage"](self, others: Union[S, Iterable[S]]) -> Self:
+        """Supplies tools from other ToolUsage instances to this instance.
+
+        Args:
+            others (ToolBoxUsage | Iterable[ToolBoxUsage]): A single ToolUsage instance or an iterable of ToolUsage instances
+                from which to take tools.
+
+        Returns:
+            Self: The current ToolUsage instance with updated tools.
+        """
+        if isinstance(others, ToolBoxUsage):
+            others = [others]
+        for other in others:
+            self.toolboxes.update(other.toolboxes)
+        return self
+
+    def provide_tools_to[S: "ToolBoxUsage"](self, others: Union[S, Iterable[S]]) -> Self:
+        """Provides tools from this instance to other ToolUsage instances.
+
+        Args:
+            others (ToolBoxUsage | Iterable[ToolBoxUsage]): A single ToolUsage instance or an iterable of ToolUsage instances
+                to which to provide tools.
+
+        Returns:
+            Self: The current ToolUsage instance.
+        """
+        if isinstance(others, ToolBoxUsage):
+            others = [others]
+        for other in others:
+            other.toolboxes.update(self.toolboxes)
+        return self

fabricatio/toolboxes/fs.py

@@ -0,0 +1,14 @@
+"""File system tool box."""
+
+from fabricatio.fs.curd import copy_file, create_directory, delete_directory, delete_file, move_file, tree
+from fabricatio.models.tool import ToolBox
+
+fs_toolbox = (
+    ToolBox(name="FsToolBox", description="A toolbox for file system operations.")
+    .add_tool(copy_file)
+    .add_tool(move_file)
+    .add_tool(delete_file)
+    .add_tool(tree)
+    .add_tool(delete_directory)
+    .add_tool(create_directory)
+)

fabricatio/toolboxes/task.py

@@ -1,3 +1,5 @@
+"""This module contains the toolbox for tasks management."""
+
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
 

{fabricatio-0.2.0.dev14.dist-info → fabricatio-0.2.0.dev17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.0.dev14
+Version: 0.2.0.dev17
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -22,6 +22,11 @@ Requires-Dist: pymitter>=1.0.0
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
+Requires-Dist: faiss-cpu>=1.10.0 ; extra == 'rag'
+Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
+Requires-Dist: fabricatio[rag] ; extra == 'full'
+Provides-Extra: rag
+Provides-Extra: full
 License-File: LICENSE
 Summary: A LLM multi-agent framework.
 Keywords: ai,agents,multi-agent,llm,pyo3

fabricatio-0.2.0.dev17.dist-info/RECORD

@@ -0,0 +1,34 @@
+fabricatio-0.2.0.dev17.dist-info/METADATA,sha256=1I6ycXWgI6ZRXlRrLYSubYm8tSkbfG8dqHYcHgCYIoc,6386
+fabricatio-0.2.0.dev17.dist-info/WHEEL,sha256=tpW5AN9B-9qsM9WW2FXG2r193YXiqexDadpKp0A2daI,96
+fabricatio-0.2.0.dev17.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/communication.py,sha256=wyc1DfhVwrwadhYG_auI9ykGXM0fwVYNwxpp91sSfiU,484
+fabricatio/actions/transmission.py,sha256=fU-xL8fDG3oRDD9x7Q94OU2Sb9G6xQfrj5IMlMYsgiM,1240
+fabricatio/actions/__init__.py,sha256=eFmFVPQvtNgFynIXBVr3eP-vWQDWCPng60YY5LXvZgg,115
+fabricatio/config.py,sha256=qT_ArV1m5CVF6No-WaUmB-Jgg_tAZ1e50A4_43x5DgE,8802
+fabricatio/core.py,sha256=yQK2ZrbPYDJOaNDp0Bky3muTkB-ZaQ1ld_Qfflm2dY0,5938
+fabricatio/decorators.py,sha256=XCnFmBoQMBB2rrJe58Kg8UP3lAyWwH9cGL7myh4FJNA,2630
+fabricatio/fs/curd.py,sha256=DulsGzat7jcR08WpP8yS1-VcDXEaaBeqnO_IZwn5kOY,3423
+fabricatio/fs/readers.py,sha256=lwAoOGafusBWyTZeN11oXJc224nPZrfafVHMmGSajkY,167
+fabricatio/fs/__init__.py,sha256=lWcKYg0v3mv2LnnSegOQaTtlVDODU0vtw_s6iKU5IqQ,122
+fabricatio/journal.py,sha256=z5K5waad9xmGr1hGrqSgFDRH3wiDQ5Oqfe0o98DaM-k,707
+fabricatio/models/action.py,sha256=YbfCZc5pWzfSsOATMaoPNwQH8uR7AOdjzqo289XVnrE,5301
+fabricatio/models/advanced.py,sha256=tJ93mrQiuIAD5lJMwEcQP1IXY2L2ihUTacyVmVaq9lA,3952
+fabricatio/models/events.py,sha256=p9uXXQNWmDcDvGuiCzeVudMC1cdwB0zSdf5FX8mEBnY,2704
+fabricatio/models/generic.py,sha256=bxH0TidKhDN8n8LOCHjPx3ViIclztHGao1N6YM1IGuQ,3425
+fabricatio/models/role.py,sha256=O0hMOGpSXFLPx2A5XhRis7BtPebG-EgT9tY9P5-8p4Y,1417
+fabricatio/models/task.py,sha256=vVOGwnT-oaIIgjemEa0riMMz_CpWdCasie2NSIRvTKM,8188
+fabricatio/models/tool.py,sha256=pOBjvOsMF6bX9cPy1mnaljzWnWE31rV1gPtTQ0ZPwxc,6389
+fabricatio/models/usages.py,sha256=PHoXqRzu7ItF0Wts4xzgN8Ek_BVTqAHOcQZXxVmU_3s,20567
+fabricatio/models/utils.py,sha256=i_kpcQpct04mQFk1nbcVGV-pl1YThWu4Qk3wbewzKkc,2535
+fabricatio/parser.py,sha256=foEhrO_e-hhRhmABcttwdMyciyJx422MpNqCZOUx8bg,3278
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
+fabricatio/toolboxes/fs.py,sha256=q5weqzAPv4RddC73blEeYYMTeXoIZjHuK55Us1yVlj0,455
+fabricatio/toolboxes/task.py,sha256=kU4a501awIDV7GwNDuSlK3_Ym-5OhCp5sS-insTmUmQ,269
+fabricatio/toolboxes/__init__.py,sha256=xWObAUPasJjBw0pY9V_XTA9fTavdQkCZSYi7-CTfOqs,415
+fabricatio/_rust.pyi,sha256=rZd_143JcGrLtRF-r5H1rErp8jQxH74n8ItA5FrohT0,1639
+fabricatio/_rust_instances.py,sha256=P5yKVZ9M9CC4ryI1G2rq4mHL96iu6DW_85RMTX8onpA,211
+fabricatio/__init__.py,sha256=C9r6OVyMBb8IqwERNUq8lKDLe4BqN7fiu-O4TsXZ5xU,913
+fabricatio/_rust.cp312-win_amd64.pyd,sha256=BaHm-8-2oT5dASWOXTsJxN17dnc3A2rRTh7RKILO8Cs,1132032
+fabricatio-0.2.0.dev17.data/scripts/tdown.exe,sha256=HsrHzB4dL8S5qCvg98dfRruvwEtwnUkPcmZcdX-efFw,3383808
+fabricatio-0.2.0.dev17.dist-info/RECORD,,

fabricatio-0.2.0.dev14.dist-info/RECORD

@@ -1,30 +0,0 @@
-fabricatio-0.2.0.dev14.dist-info/METADATA,sha256=50vUIUZqVOHUgnmW6aLwpKvDtogRa_luXfgLpNMKcB8,6198
-fabricatio-0.2.0.dev14.dist-info/WHEEL,sha256=tpW5AN9B-9qsM9WW2FXG2r193YXiqexDadpKp0A2daI,96
-fabricatio-0.2.0.dev14.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
-fabricatio/actions/communication.py,sha256=tmsr3H_w-V-b2WxLEyWByGuwSCLgHIHTdHYAgHrdUxc,425
-fabricatio/actions/transmission.py,sha256=PedZ6XsflKdT5ikzaqWr_6h8jci0kekAHfwygzKBUns,1188
-fabricatio/actions/__init__.py,sha256=eFmFVPQvtNgFynIXBVr3eP-vWQDWCPng60YY5LXvZgg,115
-fabricatio/config.py,sha256=wArRP1n3QIRwGjZOgAezdYwMYqhsrxz3D_biXAZjB28,8057
-fabricatio/core.py,sha256=yQK2ZrbPYDJOaNDp0Bky3muTkB-ZaQ1ld_Qfflm2dY0,5938
-fabricatio/decorators.py,sha256=0b8UeW6V1X6EYRgnvFlWymYOSc4nZBQNVly64JucKeY,1204
-fabricatio/fs/readers.py,sha256=mw0VUH3P7Wk0SMlcQm2yOfjEz5C3mQ_kjduAjecaxgY,123
-fabricatio/fs/__init__.py,sha256=lWcKYg0v3mv2LnnSegOQaTtlVDODU0vtw_s6iKU5IqQ,122
-fabricatio/journal.py,sha256=z5K5waad9xmGr1hGrqSgFDRH3wiDQ5Oqfe0o98DaM-k,707
-fabricatio/models/action.py,sha256=u_y89TDnP8G3g4rDuR72_a-6Ewe7_DWSywzcKeDr3vw,5280
-fabricatio/models/events.py,sha256=DDdcexweKV7jmPLHx51PIQ6eIByRrFyAMyx2VMhl9JY,2650
-fabricatio/models/generic.py,sha256=s2xz8yOlfSMnD2R9iRIe2xl12JNJXILBDfFZWzhl-xc,22932
-fabricatio/models/role.py,sha256=9DorKR1zqIn4z1HrBJIh9P8Igr-cuzh1vwcSDswfTHA,1376
-fabricatio/models/task.py,sha256=rw4RCvziUDRixE5N5miZolhYl6mvfV9dGgDxrFbJZS0,9345
-fabricatio/models/tool.py,sha256=MXjYLCsGfpjJ74oorm1OAMMFwVbP5SO09CTbxWERRjc,5504
-fabricatio/models/utils.py,sha256=i_kpcQpct04mQFk1nbcVGV-pl1YThWu4Qk3wbewzKkc,2535
-fabricatio/parser.py,sha256=foEhrO_e-hhRhmABcttwdMyciyJx422MpNqCZOUx8bg,3278
-fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
-fabricatio/toolboxes/task.py,sha256=WsMB5fSfftl975pTRXLEcnItGrmwdQfVX0Y24UyIsxs,205
-fabricatio/toolboxes/__init__.py,sha256=xWObAUPasJjBw0pY9V_XTA9fTavdQkCZSYi7-CTfOqs,415
-fabricatio/_rust.pyi,sha256=IHNv9SHdjve24PBWhdRGCqWYdo2tSAkxYR9CddHhzX8,1540
-fabricatio/_rust_instances.py,sha256=PJC8TAkcH9f1Ak-0CKxSom_HTFHQEXZ8-aSDrYw7dwI,157
-fabricatio/__init__.py,sha256=C9r6OVyMBb8IqwERNUq8lKDLe4BqN7fiu-O4TsXZ5xU,913
-fabricatio/_rust.cp312-win_amd64.pyd,sha256=wDtiezTlOmzEW_nku7u68uLZW_bePrRznTQ10SNmgcM,1125888
-fabricatio-0.2.0.dev14.data/scripts/tdown.exe,sha256=E4VwoZp3dpyJt1t4ly-4Oi0RUT6wlqlbqE4VvKVKnQg,3383296
-fabricatio-0.2.0.dev14.dist-info/RECORD,,