fabricatio 0.2.4.dev2__cp312-cp312-win_amd64.whl → 0.2.5__cp312-cp312-win_amd64.whl

fabricatio/models/usages.py

@@ -1,7 +1,7 @@
 """This module contains classes that manage the usage of language models and tools in tasks."""
 
 from asyncio import gather
-from typing import Callable, Dict, Iterable, List, Optional, Self, Set, Type, Union, Unpack, overload
+from typing import Callable, Dict, Iterable, List, Optional, Self, Sequence, Set, Type, Union, Unpack, overload
 
 import asyncstdlib
 import litellm
@@ -9,7 +9,7 @@ from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.generic import ScopedConfig, WithBriefing
-from fabricatio.models.kwargs_types import ChooseKwargs, EmbeddingKwargs, GenerateKwargs, LLMKwargs
+from fabricatio.models.kwargs_types import ChooseKwargs, EmbeddingKwargs, GenerateKwargs, LLMKwargs, ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
 from fabricatio.models.utils import Messages
@@ -20,11 +20,16 @@ from litellm.types.utils import (
     EmbeddingResponse,
     ModelResponse,
     StreamingChoices,
+    TextChoices,
 )
-from litellm.utils import CustomStreamWrapper
+from litellm.utils import CustomStreamWrapper  # pyright: ignore [reportPrivateImportUsage]
 from more_itertools import duplicates_everseen
 from pydantic import Field, NonNegativeInt, PositiveInt
 
+if configs.cache.enabled and configs.cache.type:
+    litellm.enable_cache(type=configs.cache.type, **configs.cache.params)
+    logger.success(f"{configs.cache.type.name} Cache enabled")
+
 
 class LLMUsage(ScopedConfig):
     """Class that manages LLM (Large Language Model) usage parameters and methods."""
@@ -63,6 +68,12 @@ class LLMUsage(ScopedConfig):
             max_retries=kwargs.get("max_retries") or self.llm_max_retries or configs.llm.max_retries,
             api_key=(self.llm_api_key or configs.llm.api_key).get_secret_value(),
             base_url=(self.llm_api_endpoint or configs.llm.api_endpoint).unicode_string(),
+            cache={
+                "no-cache": kwargs.get("no_cache"),
+                "no-store": kwargs.get("no_store"),
+                "cache-ttl": kwargs.get("cache_ttl"),
+                "s-maxage": kwargs.get("s_maxage"),
+            },
         )
 
     async def ainvoke(
@@ -71,7 +82,7 @@ class LLMUsage(ScopedConfig):
         system_message: str = "",
         n: PositiveInt | None = None,
         **kwargs: Unpack[LLMKwargs],
-    ) -> List[Choices | StreamingChoices]:
+    ) -> Sequence[TextChoices | Choices | StreamingChoices]:
         """Asynchronously invokes the language model with a question and optional system message.
 
         Args:
@@ -91,13 +102,14 @@ class LLMUsage(ScopedConfig):
         if isinstance(resp, ModelResponse):
             return resp.choices
         if isinstance(resp, CustomStreamWrapper):
-            if not configs.debug.streaming_visible:
-                return stream_chunk_builder(await asyncstdlib.list()).choices
+            if not configs.debug.streaming_visible and (pack := stream_chunk_builder(await asyncstdlib.list())):
+                return pack.choices
             chunks = []
             async for chunk in resp:
                 chunks.append(chunk)
                 print(chunk.choices[0].delta.content or "", end="")  # noqa: T201
-            return stream_chunk_builder(chunks).choices
+            if pack := stream_chunk_builder(chunks):
+                return pack.choices
         logger.critical(err := f"Unexpected response type: {type(resp)}")
         raise ValueError(err)
 
@@ -105,14 +117,14 @@ class LLMUsage(ScopedConfig):
     async def aask(
         self,
         question: List[str],
-        system_message: Optional[List[str]] = None,
+        system_message: List[str],
         **kwargs: Unpack[LLMKwargs],
     ) -> List[str]: ...
     @overload
     async def aask(
         self,
         question: str,
-        system_message: Optional[List[str]] = None,
+        system_message: List[str],
         **kwargs: Unpack[LLMKwargs],
     ) -> List[str]: ...
     @overload
@@ -148,103 +160,115 @@ class LLMUsage(ScopedConfig):
             str | List[str]: The content of the model's response message.
         """
         system_message = system_message or ""
-        match (isinstance(question, list), isinstance(system_message, list)):
-            case (True, True):
+        match (question, system_message):
+            case (list(q_seq), list(sm_seq)):
                 res = await gather(
                     *[
                         self.ainvoke(n=1, question=q, system_message=sm, **kwargs)
-                        for q, sm in zip(question, system_message, strict=True)
+                        for q, sm in zip(q_seq, sm_seq, strict=True)
                     ]
                 )
-                return [r.pop().message.content for r in res]
-            case (True, False):
-                res = await gather(
-                    *[self.ainvoke(n=1, question=q, system_message=system_message, **kwargs) for q in question]
-                )
-                return [r.pop().message.content for r in res]
-            case (False, True):
-                res = await gather(
-                    *[self.ainvoke(n=1, question=question, system_message=sm, **kwargs) for sm in system_message]
-                )
-                return [r.pop().message.content for r in res]
-            case (False, False):
-                return (
-                    (
-                        await self.ainvoke(
-                            n=1,
-                            question=question,
-                            system_message=system_message,
-                            **kwargs,
-                        )
-                    ).pop()
-                ).message.content
+                return [r[0].message.content for r in res]
+            case (list(q_seq), str(sm)):
+                res = await gather(*[self.ainvoke(n=1, question=q, system_message=sm, **kwargs) for q in q_seq])
+                return [r[0].message.content for r in res]
+            case (str(q), list(sm_seq)):
+                res = await gather(*[self.ainvoke(n=1, question=q, system_message=sm, **kwargs) for sm in sm_seq])
+                return [r[0].message.content for r in res]
+            case (str(q), str(sm)):
+                return ((await self.ainvoke(n=1, question=q, system_message=sm, **kwargs))[0]).message.content
             case _:
                 raise RuntimeError("Should not reach here.")
 
+    @overload
     async def aask_validate[T](
         self,
         question: str,
         validator: Callable[[str], T | None],
+        default: T,
         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.
-
-        Returns:
-            T: The validated response.
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> T: ...
+    @overload
+    async def aask_validate[T](
+        self,
+        question: List[str],
+        validator: Callable[[str], T | None],
+        default: T,
+        max_validations: PositiveInt = 2,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> List[T]: ...
+    @overload
+    async def aask_validate[T](
+        self,
+        question: str,
+        validator: Callable[[str], T | None],
+        default: None=None,
+        max_validations: PositiveInt = 2,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> Optional[T]: ...
 
-        Raises:
-            ValueError: If the response fails to validate after the maximum number of attempts.
-        """
-        for i in range(max_validations):
-            if (
-                response := await self.aask(
-                    question=question,
-                    system_message=system_message,
-                    **kwargs,
-                )
-            ) and (validated := validator(response)):
-                logger.debug(f"Successfully validated the response at {i}th attempt.")
-                return validated
-        logger.error(err := f"Failed to validate the response after {max_validations} attempts.")
-        raise ValueError(err)
+    @overload
+    async def aask_validate[T](
+        self,
+        question: List[str],
+        validator: Callable[[str], T | None],
+        default: None=None,
+        max_validations: PositiveInt = 2,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> List[Optional[T]]: ...
 
-    async def aask_validate_batch[T](
+    async def aask_validate[T](
         self,
-        questions: List[str],
+        question: str | List[str],
         validator: Callable[[str], T | None],
+        default: Optional[T] = None,
+        max_validations: PositiveInt = 2,
         **kwargs: Unpack[GenerateKwargs],
-    ) -> List[T]:
-        """Asynchronously asks a batch of questions and validates the responses using a given validator.
+    ) -> Optional[T] | List[Optional[T]] | List[T] | T:
+        """Asynchronously asks a question and validates the response using a given validator.
 
         Args:
-            questions (List[str]): The list of questions to ask.
+            question (str): The question to ask.
             validator (Callable[[str], T | None]): A function to validate the response.
-            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
+            default (T | None): Default value to return if validation fails. Defaults to None.
+            max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 2.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             T: The validated response.
 
-        Raises:
-            ValueError: If the response fails to validate after the maximum number of attempts.
         """
-        return await gather(*[self.aask_validate(question, validator, **kwargs) for question in questions])
 
-    async def aliststr(self, requirement: str, k: NonNegativeInt = 0, **kwargs: Unpack[GenerateKwargs]) -> List[str]:
+        async def _inner(q: str) -> Optional[T]:
+            for lap in range(max_validations):
+                try:
+                    if (response := await self.aask(question=q, **kwargs)) and (validated := validator(response)):
+                        logger.debug(f"Successfully validated the response at {lap}th attempt.")
+                        return validated
+                except Exception as e:  # noqa: BLE001
+                    logger.error(f"Error during validation: \n{e}")
+                    break
+                kwargs["no_cache"] = True
+                logger.debug("Closed the cache for the next attempt")
+            if default is None:
+                logger.error(f"Failed to validate the response after {max_validations} attempts.")
+            return default
+
+        if isinstance(question, str):
+            return await _inner(question)
+
+        return await gather(*[_inner(q) for q in question])
+
+    async def aliststr(
+        self, requirement: str, k: NonNegativeInt = 0, **kwargs: Unpack[ValidateKwargs[List[str]]]
+    ) -> List[str]:
         """Asynchronously generates a list of strings based on a given requirement.
 
         Args:
             requirement (str): The requirement for the list of strings.
             k (NonNegativeInt): The number of choices to select, 0 means infinite. Defaults to 0.
-            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             List[str]: The validated response as a list of strings.
@@ -258,12 +282,48 @@ class LLMUsage(ScopedConfig):
             **kwargs,
         )
 
+    async def apathstr(self, requirement: str, **kwargs: Unpack[ChooseKwargs[List[str]]]) -> List[str]:
+        """Asynchronously generates a list of strings based on a given requirement.
+
+        Args:
+            requirement (str): The requirement for the list of strings.
+            **kwargs (Unpack[ChooseKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            List[str]: The validated response as a list of strings.
+        """
+        return await self.aliststr(
+            template_manager.render_template(
+                configs.templates.pathstr_template,
+                {"requirement": requirement},
+            ),
+            **kwargs,
+        )
+
+    async def awhich_pathstr(self, requirement: str, **kwargs: Unpack[ValidateKwargs[List[str]]]) -> str:
+        """Asynchronously generates a single path string based on a given requirement.
+
+        Args:
+            requirement (str): The requirement for the list of strings.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            str: The validated response as a single string.
+        """
+        return (
+            await self.apathstr(
+                requirement,
+                k=1,
+                **kwargs,
+            )
+        ).pop()
+
     async def achoose[T: WithBriefing](
         self,
         instruction: str,
         choices: List[T],
         k: NonNegativeInt = 0,
-        **kwargs: Unpack[GenerateKwargs],
+        **kwargs: Unpack[ValidateKwargs[List[T]]],
     ) -> 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.
 
@@ -271,7 +331,7 @@ class LLMUsage(ScopedConfig):
             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.
-            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             List[T]: The final validated selection result list, with element types matching the input `choices`.
@@ -314,14 +374,14 @@ class LLMUsage(ScopedConfig):
         self,
         instruction: str,
         choices: List[T],
-        **kwargs: Unpack[GenerateKwargs],
+        **kwargs: Unpack[ValidateKwargs[List[T]]],
     ) -> T:
         """Asynchronously picks a single choice from a list of options using AI validation.
 
         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.
-            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             T: The single selected item from the choices list.
@@ -343,7 +403,7 @@ class LLMUsage(ScopedConfig):
         prompt: str,
         affirm_case: str = "",
         deny_case: str = "",
-        **kwargs: Unpack[GenerateKwargs],
+        **kwargs: Unpack[ValidateKwargs[bool]],
     ) -> bool:
         """Asynchronously judges a prompt using AI validation.
 
@@ -351,7 +411,7 @@ class LLMUsage(ScopedConfig):
             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.
-            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             bool: The judgment result (True or False) based on the AI's response.
@@ -457,18 +517,13 @@ class ToolBoxUsage(LLMUsage):
     async def choose_toolboxes(
         self,
         task: Task,
-        system_message: str = "",
-        k: NonNegativeInt = 0,
-        max_validations: PositiveInt = 2,
-        **kwargs: Unpack[LLMKwargs],
+        **kwargs: Unpack[ChooseKwargs[List[ToolBox]]],
     ) -> 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.
 
         Returns:
@@ -478,11 +533,8 @@ class ToolBoxUsage(LLMUsage):
             logger.warning("No toolboxes available.")
             return []
         return await self.achoose(
-            instruction=task.briefing,  # TODO write a template to build a more robust instruction
+            instruction=task.briefing,
             choices=list(self.toolboxes),
-            k=k,
-            max_validations=max_validations,
-            system_message=system_message,
             **kwargs,
         )
 
@@ -490,19 +542,13 @@ class ToolBoxUsage(LLMUsage):
         self,
         task: Task,
         toolbox: ToolBox,
-        system_message: str = "",
-        k: NonNegativeInt = 0,
-        max_validations: PositiveInt = 2,
-        **kwargs: Unpack[LLMKwargs],
+        **kwargs: Unpack[ChooseKwargs[List[Tool]]],
     ) -> 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.
 
         Returns:
@@ -512,11 +558,8 @@ class ToolBoxUsage(LLMUsage):
             logger.warning(f"No tools available in toolbox {toolbox.name}.")
             return []
         return await self.achoose(
-            instruction=task.briefing,  # TODO write a template to build a more robust instruction
+            instruction=task.briefing,
             choices=toolbox.tools,
-            k=k,
-            max_validations=max_validations,
-            system_message=system_message,
             **kwargs,
         )
 

fabricatio/parser.py

@@ -1,12 +1,14 @@
 """A module to parse text using regular expressions."""
 
-from typing import Any, Callable, Optional, Self, Tuple, Type
+from typing import Any, Callable, Iterable, List, Optional, Self, Tuple, Type
 
 import orjson
 import regex
+from json_repair import repair_json
 from pydantic import BaseModel, ConfigDict, Field, PositiveInt, PrivateAttr, ValidationError
 from regex import Pattern, compile
 
+from fabricatio.config import configs
 from fabricatio.journal import logger
 
 
@@ -25,12 +27,31 @@ class Capture(BaseModel):
     """The regular expression pattern to search for."""
     flags: PositiveInt = Field(default=regex.DOTALL | regex.MULTILINE | regex.IGNORECASE, frozen=True)
     """The flags to use when compiling the regular expression pattern."""
+    capture_type: Optional[str] = None
+    """The type of capture to perform, e.g., 'json', which is used to dispatch the fixer accordingly."""
     _compiled: Pattern = PrivateAttr()
 
     def model_post_init(self, __context: Any) -> None:
         """Initialize the compiled pattern."""
         self._compiled = compile(self.pattern, self.flags)
 
+    def fix[T](self, text: str | Iterable[str]|T) -> str | List[str]|T:
+        """Fix the text using the pattern.
+
+        Args:
+            text (str | List[str]): The text to fix.
+
+        Returns:
+            str | List[str]: The fixed text with the same type as input.
+        """
+        match self.capture_type:
+            case "json":
+                if isinstance(text, str):
+                    return repair_json(text,ensure_ascii=False)
+                return [repair_json(item) for item in text]
+            case _:
+                return text
+
     def capture(self, text: str) -> Tuple[str, ...] | str | None:
         """Capture the first occurrence of the pattern in the given text.
 
@@ -44,12 +65,12 @@ class Capture(BaseModel):
         match = self._compiled.search(text)
         if match is None:
             return None
-
+        groups = self.fix(match.groups()) if configs.general.use_json_repair else match.groups()
         if self.target_groups:
-            cap = tuple(match.group(g) for g in self.target_groups)
+            cap = tuple(groups[g - 1] for g in self.target_groups)
             logger.debug(f"Captured text: {'\n\n'.join(cap)}")
             return cap
-        cap = match.group(1)
+        cap = groups[0]
         logger.debug(f"Captured text: \n{cap}")
         return cap
 
@@ -111,7 +132,7 @@ class Capture(BaseModel):
         Returns:
             Self: The instance of the class with the captured code block.
         """
-        return cls(pattern=f"```{language}\n(.*?)\n```")
+        return cls(pattern=f"```{language}\n(.*?)\n```", capture_type=language)
 
 
 JsonCapture = Capture.capture_code_block("json")

fabricatio/toolboxes/__init__.py

@@ -5,13 +5,11 @@ from typing import Set
 from fabricatio.models.tool import ToolBox
 from fabricatio.toolboxes.arithmetic import arithmetic_toolbox
 from fabricatio.toolboxes.fs import fs_toolbox
-from fabricatio.toolboxes.task import task_toolbox
 
-basic_toolboxes: Set[ToolBox] = {task_toolbox, arithmetic_toolbox}
+basic_toolboxes: Set[ToolBox] = {arithmetic_toolbox}
 
 __all__ = [
     "arithmetic_toolbox",
     "basic_toolboxes",
     "fs_toolbox",
-    "task_toolbox",
 ]

fabricatio/toolboxes/fs.py

@@ -1,6 +1,18 @@
 """File system tool box."""
 
-from fabricatio.fs.curd import copy_file, create_directory, delete_directory, delete_file, dump_text, move_file, tree
+from fabricatio.fs import (
+    absolute_path,
+    copy_file,
+    create_directory,
+    delete_directory,
+    delete_file,
+    dump_text,
+    gather_files,
+    move_file,
+    safe_json_read,
+    safe_text_read,
+    tree,
+)
 from fabricatio.models.tool import ToolBox
 
 fs_toolbox = (
@@ -12,4 +24,8 @@ fs_toolbox = (
     .add_tool(tree)
     .add_tool(delete_directory)
     .add_tool(create_directory)
+    .add_tool(absolute_path)
+    .add_tool(safe_text_read)
+    .add_tool(safe_json_read)
+    .add_tool(gather_files)
 )

fabricatio/workflows/articles.py

@@ -1,11 +1,15 @@
 """Store article essence in the database."""
 
-from fabricatio.actions.article import ExtractArticleEssence
-from fabricatio.actions.rag import InjectToDB
+from fabricatio.actions.article import GenerateArticleProposal, GenerateOutline
+from fabricatio.actions.output import DumpFinalizedOutput
 from fabricatio.models.action import WorkFlow
 
-StoreArticle = WorkFlow(
-    name="Extract Article Essence",
-    description="Extract the essence of an article in the given path, and store it in the database.",
-    steps=(ExtractArticleEssence(output_key="to_inject"), InjectToDB(output_key="task_output")),
+WriteOutlineWorkFlow = WorkFlow(
+    name="Generate Article Outline",
+    description="Generate an outline for an article. dump the outline to the given path. in typst format.",
+    steps=(
+        GenerateArticleProposal,
+        GenerateOutline(output_key="to_dump"),
+        DumpFinalizedOutput(output_key="task_output"),
+    ),
 )

fabricatio/workflows/rag.py

@@ -0,0 +1,11 @@
+"""The workflow for extracting the essence of an article and storing it in the database."""
+
+from fabricatio.actions.article import ExtractArticleEssence
+from fabricatio.actions.rag import InjectToDB
+from fabricatio.models.action import WorkFlow
+
+StoreArticle = WorkFlow(
+    name="Extract Article Essence",
+    description="Extract the essence of an article in the given path, and store it in the database.",
+    steps=(ExtractArticleEssence(output_key="to_inject"), InjectToDB(output_key="task_output")),
+)

{fabricatio-0.2.4.dev2.dist-info → fabricatio-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.4.dev2
+Version: 0.2.5
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -11,6 +11,7 @@ Classifier: Typing :: Typed
 Requires-Dist: appdirs>=1.4.4
 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: magika>=0.5.1

fabricatio-0.2.5.dist-info/RECORD

@@ -0,0 +1,41 @@
+fabricatio-0.2.5.dist-info/METADATA,sha256=AOoGHQbgVdQW0GXyg5pXbONeKgMRLgSc-9XER1YWix4,8891
+fabricatio-0.2.5.dist-info/WHEEL,sha256=tpW5AN9B-9qsM9WW2FXG2r193YXiqexDadpKp0A2daI,96
+fabricatio-0.2.5.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/article.py,sha256=yzRwgc203vI3MW_oWyFybDxTz6kaBBvUgN2zOJJ9Amc,2825
+fabricatio/actions/output.py,sha256=RWXulsfN_qrCFik0B6lGwXf6MMtgK3CaF1ENbK0l85o,684
+fabricatio/actions/rag.py,sha256=wBygtCHVBIvRAhsQRz6pJv2-QDsGtV6fEo8IdOvfVoM,831
+fabricatio/capabilities/propose.py,sha256=y3kge5g6bb8HYuV8e9h4MdqOMTlsfAIZpqE_cagWPTY,1593
+fabricatio/capabilities/rag.py,sha256=YYaabej-f6a7gBRbJRcJ_Fj89BloNCw0sHOPqs_W8Bk,15773
+fabricatio/capabilities/rating.py,sha256=0Xrfp_AW9u2ltHnZXxz3Pt3fr8fMsO0QiFadegh49IU,14406
+fabricatio/capabilities/review.py,sha256=4FbM8dO-JSPnu22I1lykM9y1gzBtXI5Wj33KtzvULWU,9757
+fabricatio/capabilities/task.py,sha256=qH3Zmq3FxM5bcnIGqTm55KyU5Mt001Ly7fqcaEHPHiU,4595
+fabricatio/config.py,sha256=pZruV1dL-U1_ynb6_GoZuaKEnDqPmDMJ45ycWXEjlCw,14894
+fabricatio/core.py,sha256=VQ_JKgUGIy2gZ8xsTBZCdr_IP7wC5aPg0_bsOmjQ588,6458
+fabricatio/decorators.py,sha256=uzsP4tFKQNjDHBkofsjjoJA0IUAaYOtt6YVedoyOqlo,6551
+fabricatio/fs/curd.py,sha256=N6l2MncjrFfnXBRtteRouXp5Rjy8EAKC_i29_G-zz98,4618
+fabricatio/fs/readers.py,sha256=RNWx4T2XXigeprJOxw8YjHfyGlrCtB5MVz01Gw9lvw4,1202
+fabricatio/fs/__init__.py,sha256=uk4yIlz43Yl2mQZ5QuoMstg0DaIQV9h6XXxU4SbdWpY,588
+fabricatio/journal.py,sha256=pCpIFk-IOsDmCcjx1fOsWDDxjkeAGYgu2OrFnuItwcA,801
+fabricatio/models/action.py,sha256=MZZ3jQcMcjKXJ8h5L-gedeJGPYghyTcRo_wF38g8LIE,6461
+fabricatio/models/events.py,sha256=QvlnS8FEELg6KNabcJMeh2GV_y0ZBzKOPphcteKYWYU,4183
+fabricatio/models/extra.py,sha256=O8ncZVsaNmlR5f8c_b2HJc-yVZQ2YhB6ddDbfT0Ysh4,7412
+fabricatio/models/generic.py,sha256=diqQ3qwh6rlE7PjFTBYhVVCc3srYU-8R8D9Rk8ESOfM,13594
+fabricatio/models/kwargs_types.py,sha256=RKD_EXMlz4vuVpGzB9y5qDotSHNOKjk6R0EI4BoNaCg,4282
+fabricatio/models/role.py,sha256=M9JVDmLLvJhY3G0hHMdcs1ywJ0eoAb6CLYbzhv-l_8s,1839
+fabricatio/models/task.py,sha256=sbC0EAZC4rPL2GCJ9i9GlFcZUJ96g39SQ2QP8bbgdqs,10492
+fabricatio/models/tool.py,sha256=4b-v4WIC_LuLOKzzXL9bvKXr8vmGZ8O2uAFv5-1KRA0,7052
+fabricatio/models/usages.py,sha256=badtIf2622DJGfrLnEMxDKaIAQSI0n2Kx1m7TeVFsGE,26681
+fabricatio/models/utils.py,sha256=QI3bYrKBbzLbKvyzVrZXGcWq3trOOTE-hQAC_WNvjMg,4457
+fabricatio/parser.py,sha256=pwYAoLbWYXtABcnV3s5GdBM0Ngczq-r7n0jKSnpdAxE,5838
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
+fabricatio/toolboxes/fs.py,sha256=l4L1CVxJmjw9Ld2XUpIlWfV0_Fu_2Og6d3E13I-S4aE,736
+fabricatio/toolboxes/__init__.py,sha256=KBJi5OG_pExscdlM7Bnt_UF43j4I3Lv6G71kPVu4KQU,395
+fabricatio/workflows/articles.py,sha256=RebdC_BzSXC-xsck5I9ccC_XIgfhtoeM8FZuhtVDn3U,580
+fabricatio/workflows/rag.py,sha256=-YYp2tlE9Vtfgpg6ROpu6QVO8j8yVSPa6yDzlN3qVxs,520
+fabricatio/_rust.pyi,sha256=pI747rOciunGuQZDvfC3O0A6pLyOiaHSa3A5kHuQO0E,3169
+fabricatio/_rust_instances.py,sha256=RybIzB2kCoMeU_1kMm2JTz1ka8i524hAra66joDf--s,314
+fabricatio/__init__.py,sha256=22KLRAVoJZUrK7gsDjU1NfiLCnZtV-qgx6TO2YMbuH8,1930
+fabricatio/_rust.cp312-win_amd64.pyd,sha256=6oc15oD6KF9Q-1yeYuUKKN8kv4haUb5JXTkoGY0_QPU,1816064
+fabricatio-0.2.5.data/scripts/tdown.exe,sha256=ZSK6gpbQmPFCkhdCFM7oGebLCOrqptLjzmoQ2EVXEhs,3395072
+fabricatio-0.2.5.dist-info/RECORD,,

fabricatio/toolboxes/task.py

@@ -1,6 +0,0 @@
-"""This module contains the toolbox for tasks management."""
-
-from fabricatio.models.task import Task
-from fabricatio.models.tool import ToolBox
-
-task_toolbox = ToolBox(name="TaskToolBox", description="A toolbox for tasks management.").add_tool(Task.simple_task)