fabricatio 0.2.8.dev3__cp312-cp312-win_amd64.whl → 0.2.9.dev0__cp312-cp312-win_amd64.whl

fabricatio/models/tool.py

@@ -1,4 +1,8 @@
-"""A module for defining tools and toolboxes."""
+"""A module for defining tools and toolboxes.
+
+This module provides classes for defining tools and toolboxes, which can be used to manage and execute callable functions
+with additional functionalities such as logging, execution info, and briefing.
+"""
 
 from importlib.machinery import ModuleSpec
 from importlib.util import module_from_spec
@@ -14,7 +18,16 @@ from pydantic import BaseModel, ConfigDict, Field
 
 
 class Tool[**P, R](WithBriefing):
-    """A class representing a tool with a callable source function."""
+    """A class representing a tool with a callable source function.
+
+    This class encapsulates a callable function (source) and provides methods to invoke it, log its execution, and generate
+    a brief description (briefing) of the tool.
+
+    Attributes:
+        name (str): The name of the tool.
+        description (str): The description of the tool.
+        source (Callable[P, R]): The source function of the tool.
+    """
 
     name: str = Field(default="")
     """The name of the tool."""
@@ -26,7 +39,16 @@ class Tool[**P, R](WithBriefing):
     """The source function of the tool."""
 
     def model_post_init(self, __context: Any) -> None:
-        """Initialize the tool with a name and a source function."""
+        """Initialize the tool with a name and a source function.
+
+        This method sets the tool's name and description based on the source function's name and docstring.
+
+        Args:
+            __context (Any): Context passed during model initialization.
+
+        Raises:
+            RuntimeError: If the tool does not have a source function.
+        """
         self.name = self.name or self.source.__name__
 
         if not self.name:
@@ -36,7 +58,17 @@ class Tool[**P, R](WithBriefing):
         self.description = self.description.strip()
 
     def invoke(self, *args: P.args, **kwargs: P.kwargs) -> R:
-        """Invoke the tool's source function with the provided arguments."""
+        """Invoke the tool's source function with the provided arguments.
+
+        This method logs the invocation of the tool and then calls the source function with the given arguments.
+
+        Args:
+            *args (P.args): Positional arguments to be passed to the source function.
+            **kwargs (P.kwargs): Keyword arguments to be passed to the source function.
+
+        Returns:
+            R: The result of the source function.
+        """
         logger.info(f"Invoking tool: {self.name}")
         return self.source(*args, **kwargs)
 
@@ -44,6 +76,8 @@ class Tool[**P, R](WithBriefing):
     def briefing(self) -> str:
         """Return a brief description of the tool.
 
+        This method generates a brief description of the tool, including its name, signature, and description.
+
         Returns:
             str: A brief description of the tool.
         """
@@ -59,7 +93,18 @@ def _desc_wrapper(desc: str) -> str:
 
 
 class ToolBox(WithBriefing):
-    """A class representing a collection of tools."""
+    """A class representing a collection of tools.
+
+    This class manages a list of tools and provides methods to add tools, retrieve tools by name, and generate a brief
+    description (briefing) of the toolbox.
+
+    Attributes:
+        description (str): The description of the toolbox.
+        tools (List[Tool]): A list of tools in the toolbox.
+    """
+
+    description: str = ""
+    """The description of the toolbox."""
 
     tools: List[Tool] = Field(default_factory=list, frozen=True)
     """A list of tools in the toolbox."""
@@ -67,6 +112,8 @@ class ToolBox(WithBriefing):
     def collect_tool[**P, R](self, func: Callable[P, R]) -> Callable[P, R]:
         """Add a callable function to the toolbox as a tool.
 
+        This method wraps the function with logging execution info and adds it to the toolbox.
+
         Args:
             func (Callable[P, R]): The function to be added as a tool.
 
@@ -79,6 +126,8 @@ class ToolBox(WithBriefing):
     def add_tool[**P, R](self, func: Callable[P, R]) -> Self:
         """Add a callable function to the toolbox as a tool.
 
+        This method wraps the function with logging execution info and adds it to the toolbox.
+
         Args:
             func (Callable): The function to be added as a tool.
 
@@ -92,6 +141,8 @@ class ToolBox(WithBriefing):
     def briefing(self) -> str:
         """Return a brief description of the toolbox.
 
+        This method generates a brief description of the toolbox, including its name, description, and a list of tools.
+
         Returns:
             str: A brief description of the toolbox.
         """
@@ -102,6 +153,8 @@ class ToolBox(WithBriefing):
     def get[**P, R](self, name: str) -> Tool[P, R]:
         """Invoke a tool by name with the provided arguments.
 
+        This method retrieves a tool by its name from the toolbox.
+
         Args:
             name (str): The name of the tool to invoke.
 
@@ -120,13 +173,24 @@ class ToolBox(WithBriefing):
         return tool
 
     def __hash__(self) -> int:
-        """Return a hash of the toolbox based on its briefing."""
+        """Return a hash of the toolbox based on its briefing.
+
+        Returns:
+            int: A hash value based on the toolbox's briefing.
+        """
         return hash(self.briefing)
 
 
 class ToolExecutor(BaseModel):
-    """A class representing a tool executor with a sequence of tools to execute."""
+    """A class representing a tool executor with a sequence of tools to execute.
+
+    This class manages a sequence of tools and provides methods to inject tools and data into a module, execute the tools,
+    and retrieve specific outputs.
 
+    Attributes:
+        candidates (List[Tool]): The sequence of tools to execute.
+        data (Dict[str, Any]): The data that could be used when invoking the tools.
+    """
     model_config = ConfigDict(use_attribute_docstrings=True)
     candidates: List[Tool] = Field(default_factory=list, frozen=True)
     """The sequence of tools to execute."""
@@ -135,7 +199,16 @@ class ToolExecutor(BaseModel):
     """The data that could be used when invoking the tools."""
 
     def inject_tools[M: ModuleType](self, module: Optional[M] = None) -> M:
-        """Inject the tools into the provided module or default."""
+        """Inject the tools into the provided module or default.
+
+        This method injects the tools into the provided module or creates a new module if none is provided.
+
+        Args:
+            module (Optional[M]): The module to inject tools into. If None, a new module is created.
+
+        Returns:
+            M: The module with injected tools.
+        """
         module = module or cast(
             "M", module_from_spec(spec=ModuleSpec(name=configs.toolbox.tool_module_name, loader=None))
         )
@@ -145,7 +218,16 @@ class ToolExecutor(BaseModel):
         return module
 
     def inject_data[M: ModuleType](self, module: Optional[M] = None) -> M:
-        """Inject the data into the provided module or default."""
+        """Inject the data into the provided module or default.
+
+        This method injects the data into the provided module or creates a new module if none is provided.
+
+        Args:
+            module (Optional[M]): The module to inject data into. If None, a new module is created.
+
+        Returns:
+            M: The module with injected data.
+        """
         module = module or cast(
             'M', module_from_spec(spec=ModuleSpec(name=configs.toolbox.data_module_name, loader=None))
         )
@@ -155,7 +237,17 @@ class ToolExecutor(BaseModel):
         return module
 
     def execute[C: Dict[str, Any]](self, source: CodeType, cxt: Optional[C] = None) -> C:
-        """Execute the sequence of tools with the provided context."""
+        """Execute the sequence of tools with the provided context.
+
+        This method executes the tools in the sequence with the provided context.
+
+        Args:
+            source (CodeType): The source code to execute.
+            cxt (Optional[C]): The context to execute the tools with. If None, an empty dictionary is used.
+
+        Returns:
+            C: The context after executing the tools.
+        """
         cxt = cxt or {}
 
         @use_temp_module([self.inject_data(), self.inject_tools()])
@@ -167,16 +259,49 @@ class ToolExecutor(BaseModel):
 
     @overload
     def take[C: Dict[str, Any]](self, keys: List[str], source: CodeType, cxt: Optional[C] = None) -> C:
-        """Check the output of the tools with the provided context."""
+        """Check the output of the tools with the provided context.
+
+        This method executes the tools and retrieves specific keys from the context.
+
+        Args:
+            keys (List[str]): The keys to retrieve from the context.
+            source (CodeType): The source code to execute.
+            cxt (Optional[C]): The context to execute the tools with. If None, an empty dictionary is used.
+
+        Returns:
+            C: A dictionary containing the retrieved keys and their values.
+        """
         ...
 
     @overload
     def take[C: Dict[str, Any]](self, keys: str, source: CodeType, cxt: Optional[C] = None) -> Any:
-        """Check the output of the tools with the provided context."""
+        """Check the output of the tools with the provided context.
+
+        This method executes the tools and retrieves a specific key from the context.
+
+        Args:
+            keys (str): The key to retrieve from the context.
+            source (CodeType): The source code to execute.
+            cxt (Optional[C]): The context to execute the tools with. If None, an empty dictionary is used.
+
+        Returns:
+            Any: The value of the retrieved key.
+        """
         ...
 
     def take[C: Dict[str, Any]](self, keys: List[str] | str, source: CodeType, cxt: Optional[C] = None) -> C | Any:
-        """Check the output of the tools with the provided context."""
+        """Check the output of the tools with the provided context.
+
+        This method executes the tools and retrieves specific keys or a specific key from the context.
+
+        Args:
+            keys (List[str] | str): The keys to retrieve from the context. Can be a single key or a list of keys.
+            source (CodeType): The source code to execute.
+            cxt (Optional[C]): The context to execute the tools with. If None, an empty dictionary is used.
+
+        Returns:
+            C | Any: A dictionary containing the retrieved keys and their values, or the value of the retrieved key.
+        """
         cxt = self.execute(source, cxt)
         if isinstance(keys, str):
             return cxt[keys]
@@ -184,7 +309,17 @@ class ToolExecutor(BaseModel):
 
     @classmethod
     def from_recipe(cls, recipe: List[str], toolboxes: List[ToolBox]) -> Self:
-        """Create a tool executor from a recipe and a list of toolboxes."""
+        """Create a tool executor from a recipe and a list of toolboxes.
+
+        This method creates a tool executor by retrieving tools from the provided toolboxes based on the recipe.
+
+        Args:
+            recipe (List[str]): The recipe specifying the names of the tools to be added.
+            toolboxes (List[ToolBox]): The list of toolboxes to retrieve tools from.
+
+        Returns:
+            Self: A new instance of the tool executor with the specified tools.
+        """
         tools = []
         while tool_name := recipe.pop(0):
             for toolbox in toolboxes:

fabricatio/models/usages.py

@@ -2,11 +2,10 @@
 
 import traceback
 from asyncio import gather
-from typing import Callable, Dict, Iterable, List, Optional, Self, Sequence, Set, Type, Union, Unpack, overload
+from typing import Callable, Dict, Iterable, List, Optional, Self, Sequence, Set, Union, Unpack, overload
 
 import asyncstdlib
 import litellm
-from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
 from fabricatio.decorators import logging_exec_time
 from fabricatio.journal import logger
@@ -16,6 +15,7 @@ from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
 from fabricatio.models.utils import Messages
 from fabricatio.parser import GenericCapture, JsonCapture
+from fabricatio.rust_instances import TEMPLATE_MANAGER
 from fabricatio.utils import ok
 from litellm import RateLimitError, Router, stream_chunk_builder  # pyright: ignore [reportPrivateImportUsage]
 from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
@@ -46,17 +46,24 @@ ROUTER = Router(
 
 
 class LLMUsage(ScopedConfig):
-    """Class that manages LLM (Large Language Model) usage parameters and methods."""
+    """Class that manages LLM (Large Language Model) usage parameters and methods.
+
+    This class provides methods to deploy LLMs, query them for responses, and handle various configurations
+    related to LLM usage such as API keys, endpoints, and rate limits.
+    """
 
     def _deploy(self, deployment: Deployment) -> Router:
-        """Add a deployment to the router."""
+        """Add a deployment to the router.
+
+        Args:
+            deployment (Deployment): The deployment to be added to the router.
+
+        Returns:
+            Router: The updated router with the added deployment.
+        """
         self._added_deployment = ROUTER.upsert_deployment(deployment)
         return ROUTER
 
-    @classmethod
-    def _scoped_model(cls) -> Type["LLMUsage"]:
-        return LLMUsage
-
     # noinspection PyTypeChecker,PydanticTypeChecker
     async def aquery(
         self,
@@ -136,7 +143,7 @@ class LLMUsage(ScopedConfig):
             **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            List[Choices | StreamingChoices]: A list of choices or streaming choices from the model response.
+            Sequence[TextChoices | Choices | StreamingChoices]: A sequence of choices or streaming choices from the model response.
         """
         resp = await self.aquery(
             messages=Messages().add_system_message(system_message).add_user_message(question).as_list(),
@@ -288,27 +295,25 @@ class LLMUsage(ScopedConfig):
         """Asynchronously asks a question and validates the response using a given validator.
 
         Args:
-            question (str): The question to ask.
+            question (str | List[str]): The question to ask.
             validator (Callable[[str], T | None]): A function to validate the response.
             default (T | None): Default value to return if validation fails. Defaults to None.
-            max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 2.
+            max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 3.
             co_extractor (Optional[GenerateKwargs]): Keyword arguments for the co-extractor, if provided will enable co-extraction.
-            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
+            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            T: The validated response.
-
+            Optional[T] | List[Optional[T]] | List[T] | T: The validated response.
         """
 
         async def _inner(q: str) -> Optional[T]:
             for lap in range(max_validations):
                 try:
-                    if (
-                        (response := await self.aask(question=q, **kwargs))
-                        or (
-                            co_extractor
-                            and (
-                                response := await self.aask(
+                    if ((validated := validator(response := await self.aask(question=q, **kwargs))) is not None) or (
+                        co_extractor
+                        and (
+                            validated := validator(
+                                await self.aask(
                                     question=(
                                         TEMPLATE_MANAGER.render_template(
                                             configs.templates.co_validation_template,
@@ -319,7 +324,8 @@ class LLMUsage(ScopedConfig):
                                 )
                             )
                         )
-                    ) and (validated := validator(response)):
+                        is not None
+                    ):
                         logger.debug(f"Successfully validated the response at {lap}th attempt.")
                         return validated
 
@@ -350,7 +356,7 @@ class LLMUsage(ScopedConfig):
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            List[str]: The validated response as a list of strings.
+            Optional[List[str]]: The validated response as a list of strings.
         """
         return await self.aask_validate(
             TEMPLATE_MANAGER.render_template(
@@ -361,7 +367,6 @@ class LLMUsage(ScopedConfig):
             **kwargs,
         )
 
-
     async def apathstr(self, requirement: str, **kwargs: Unpack[ChooseKwargs[List[str]]]) -> Optional[List[str]]:
         """Asynchronously generates a list of strings based on a given requirement.
 
@@ -370,7 +375,7 @@ class LLMUsage(ScopedConfig):
             **kwargs (Unpack[ChooseKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            List[str]: The validated response as a list of strings.
+            Optional[List[str]]: The validated response as a list of strings.
         """
         return await self.alist_str(
             TEMPLATE_MANAGER.render_template(
@@ -388,7 +393,7 @@ class LLMUsage(ScopedConfig):
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            str: The validated response as a single string.
+            Optional[str]: The validated response as a single string.
         """
         if paths := await self.apathstr(
             requirement,
@@ -407,7 +412,7 @@ class LLMUsage(ScopedConfig):
             **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            str: The generated string.
+            Optional[str]: The generated string.
         """
         return await self.aask_validate(  # pyright: ignore [reportReturnType]
             TEMPLATE_MANAGER.render_template(
@@ -434,12 +439,7 @@ class LLMUsage(ScopedConfig):
             **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`.
-
-        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.
+            Optional[List[T]]: The final validated selection result list, with element types matching the input `choices`.
         """
         if dup := duplicates_everseen(choices, key=lambda x: x.name):
             logger.error(err := f"Redundant choices: {dup}")
@@ -527,7 +527,10 @@ class LLMUsage(ScopedConfig):
 
 
 class EmbeddingUsage(LLMUsage):
-    """A class representing the embedding model."""
+    """A class representing the embedding model.
+
+    This class extends LLMUsage and provides methods to generate embeddings for input text using various models.
+    """
 
     async def aembedding(
         self,
@@ -546,13 +549,12 @@ class EmbeddingUsage(LLMUsage):
             timeout (Optional[PositiveInt]): The timeout for the embedding request. Defaults to the instance's `llm_timeout` or the global configuration.
             caching (Optional[bool]): Whether to cache the embedding result. Defaults to False.
 
-
         Returns:
             EmbeddingResponse: The response containing the embeddings.
         """
         # check seq length
         max_len = self.embedding_max_sequence_length or configs.embedding.max_sequence_length
-        if max_len and any(length:=(token_counter(text=t)) > max_len for t in input_text):
+        if max_len and any(length := (token_counter(text=t)) > max_len for t in input_text):
             logger.error(err := f"Input text exceeds maximum sequence length {max_len}, got {length}.")
             raise ValueError(err)
 
@@ -604,14 +606,21 @@ class EmbeddingUsage(LLMUsage):
 
 
 class ToolBoxUsage(LLMUsage):
-    """A class representing the usage of tools in a task."""
+    """A class representing the usage of tools in a task.
+
+    This class extends LLMUsage and provides methods to manage and use toolboxes and tools within tasks.
+    """
 
     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 a list of available toolbox names.
+
+        Returns:
+            List[str]: A list of names of the available toolboxes.
+        """
         return [toolbox.name for toolbox in self.toolboxes]
 
     async def choose_toolboxes(
@@ -623,11 +632,10 @@ class ToolBoxUsage(LLMUsage):
 
         Args:
             task (Task): The task for which to choose toolboxes.
-            system_message (str): Custom system-level prompt, defaults to an empty string.
             **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            List[ToolBox]: The selected toolboxes.
+            Optional[List[ToolBox]]: The selected toolboxes.
         """
         if not self.toolboxes:
             logger.warning("No toolboxes available.")
@@ -652,7 +660,7 @@ class ToolBoxUsage(LLMUsage):
             **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            List[Tool]: The selected tools.
+            Optional[List[Tool]]: The selected tools.
         """
         if not toolbox.tools:
             logger.warning(f"No tools available in toolbox {toolbox.name}.")
@@ -714,7 +722,7 @@ class ToolBoxUsage(LLMUsage):
         """
         if isinstance(others, ToolBoxUsage):
             others = [others]
-        for other in others:
+        for other in (x for x in others if isinstance(x, ToolBoxUsage)):
             self.toolboxes.update(other.toolboxes)
         return self
 
@@ -730,6 +738,6 @@ class ToolBoxUsage(LLMUsage):
         """
         if isinstance(others, ToolBoxUsage):
             others = [others]
-        for other in others:
+        for other in (x for x in others if isinstance(x, ToolBoxUsage)):
             other.toolboxes.update(self.toolboxes)
         return self

fabricatio/parser.py

@@ -45,14 +45,14 @@ class Capture(BaseModel):
             str | List[str]: The fixed text with the same type as input.
         """
         match self.capture_type:
-            case "json":
+            case "json" if configs.general.use_json_repair:
+                logger.debug("Applying json repair to text.")
                 if isinstance(text, str):
                     return repair_json(text, ensure_ascii=False)
                 return [repair_json(item, ensure_ascii=False) 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.
 
@@ -63,11 +63,10 @@ class Capture(BaseModel):
             str | None: The captured text if the pattern is found, otherwise None.
 
         """
-        match = self._compiled.search(text)
-        if match is None:
-            logger.debug(f"Capture Failed: \n{text}")
+        if (match :=self._compiled.match(text) or self._compiled.search(text) ) is None:
+            logger.debug(f"Capture Failed {type(text)}: \n{text}")
             return None
-        groups = self.fix(match.groups()) if configs.general.use_json_repair else match.groups()
+        groups = self.fix(match.groups())
         if self.target_groups:
             cap = tuple(groups[g - 1] for g in self.target_groups)
             logger.debug(f"Captured text: {'\n\n'.join(cap)}")
@@ -134,7 +133,7 @@ class Capture(BaseModel):
         Returns:
             Self: The instance of the class with the captured code block.
         """
-        return cls(pattern=f"```{language}\n(.*?)\n```", capture_type=language)
+        return cls(pattern=f"```{language}(.*?)```", capture_type=language)
 
     @classmethod
     def capture_generic_block(cls, language: str) -> Self:
@@ -143,7 +142,7 @@ class Capture(BaseModel):
         Returns:
             Self: The instance of the class with the captured code block.
         """
-        return cls(pattern=f"--- Start of {language} ---\n(.*?)\n--- end of {language} ---", capture_type=language)
+        return cls(pattern=f"--- Start of {language} ---(.*?)--- end of {language} ---", capture_type=language)
 
 
 JsonCapture = Capture.capture_code_block("json")

fabricatio/{_rust_instances.py → rust_instances.py}

@@ -1,7 +1,7 @@
 """Some necessary instances."""
 
-from fabricatio._rust import TemplateManager
 from fabricatio.config import configs
+from fabricatio.rust import TemplateManager
 
 TEMPLATE_MANAGER = TemplateManager(
     template_dirs=configs.templates.template_dir,

fabricatio/workflows/__init__.py

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

{fabricatio-0.2.8.dev3.dist-info → fabricatio-0.2.9.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.8.dev3
+Version: 0.2.9.dev0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

fabricatio-0.2.9.dev0.dist-info/RECORD

@@ -0,0 +1,61 @@
+fabricatio-0.2.9.dev0.dist-info/METADATA,sha256=BMpvwW9IuEvcJ_WzIZQmvQc4bGRogNfCZlyuCYNo0M8,5288
+fabricatio-0.2.9.dev0.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
+fabricatio-0.2.9.dev0.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/article.py,sha256=D-9aGLC1eW9w_aNICGNpdkUm7jx01h8nBcAPSW_Da7E,12788
+fabricatio/actions/article_rag.py,sha256=dkfskNqntVPi81Xm_NFdTQM8v2nR9FJIexzkK9rg-NU,4352
+fabricatio/actions/output.py,sha256=-FfTzXEHIb_zOT-j4T4b5ND96zHLDEGdjlmmPviIbiM,3754
+fabricatio/actions/rag.py,sha256=5nSih3YUkdt1uU02hSAMW6sADq9mkMOR1wDv7zIrIGQ,2737
+fabricatio/actions/rules.py,sha256=pA6ADNgpPWBp2a3FTEuF--0INHg0QJxc0kfxF1zMDXQ,1541
+fabricatio/actions/__init__.py,sha256=wVENCFtpVb1rLFxoOFJt9-8smLWXuJV7IwA8P3EfFz4,48
+fabricatio/capabilities/advanced_judge.py,sha256=selB0Gwf1F4gGJlwBiRo6gI4KOUROgh3WnzO3mZFEls,706
+fabricatio/capabilities/censor.py,sha256=J-YgwnDus3vKDpeFENhGvUSxvpC8FnhhnWJe1RffcqI,3869
+fabricatio/capabilities/check.py,sha256=uzxiar7bHGgxu7JqU8tRSncN3KP6xo5r3c8wvyBd3M8,8287
+fabricatio/capabilities/correct.py,sha256=I9RWmFjwXEjbYzIgtyFbqc0RvTpHeMHdGT9tuKHwCtY,9177
+fabricatio/capabilities/propose.py,sha256=hkBeSlmcTdfYWT-ph6nlbtHXBozi_JXqXlWcnBy3W78,2007
+fabricatio/capabilities/rag.py,sha256=8TTJSV2Tz0naXyOQ5c_RQ4h9ZxyOOSE7BvyWxKkQMU0,17722
+fabricatio/capabilities/rating.py,sha256=5HjWGk-tFscnMo4cFTAE820yeOaXT9utNSRKVrSTbSA,17012
+fabricatio/capabilities/review.py,sha256=-EMZe0ADFPT6fPGmra16UPjJC1M3rAs6dPFdTZ88Fgg,5060
+fabricatio/capabilities/task.py,sha256=JahC61X233UIPsjovxJgc_yqj_BjWZJBCzJZq11M2Xk,4417
+fabricatio/capabilities/__init__.py,sha256=v1cHRHIJ2gxyqMLNCs6ERVcCakSasZNYzmMI4lqAcls,57
+fabricatio/config.py,sha256=Q9VHk4T8ajJEPPckjUuhJ0vjvqc79zufUbek_5GHTbE,17679
+fabricatio/core.py,sha256=VQ_JKgUGIy2gZ8xsTBZCdr_IP7wC5aPg0_bsOmjQ588,6458
+fabricatio/decorators.py,sha256=C0Gi7wcXC-0sWITqsSv3JdBGcgVJOlRvOt0FfO0aUsA,7554
+fabricatio/fs/curd.py,sha256=p8y0LGKgVDk-CWOlm37E6wg7RK6RCD6denKo-VsW28c,4763
+fabricatio/fs/readers.py,sha256=EZKN_AZdrp8DggJECP53QHw3uHeSDf-AwCAA_V7fNKU,1202
+fabricatio/fs/__init__.py,sha256=PCf0s_9KDjVfNw7AfPoJzGt3jMq4gJOfbcT4pb0D0ZY,588
+fabricatio/journal.py,sha256=stnEP88aUBA_GmU9gfTF2EZI8FS2OyMLGaMSTgK4QgA,476
+fabricatio/models/action.py,sha256=C0PnZ5ycLcqcQ5s1h4KcLJXc1ZZmxYRfCQvz2DuSAOo,9229
+fabricatio/models/adv_kwargs_types.py,sha256=dcYMLn6xcnWLZTLTBdtpgUZWi-VBeub721GzHRZFT1g,860
+fabricatio/models/events.py,sha256=QvlnS8FEELg6KNabcJMeh2GV_y0ZBzKOPphcteKYWYU,4183
+fabricatio/models/extra/advanced_judge.py,sha256=mi3KiB8FUuSYICzXPXKwVhCyRE1GL3gHLkwuc-4mh3c,999
+fabricatio/models/extra/article_base.py,sha256=1Fg3iWbod1TCU3nIJK9mOq_8K3oGBtSW03VUwi2I5tg,17058
+fabricatio/models/extra/article_essence.py,sha256=xd6j-PDqjhrMjgUmyfk6HqkyMLu-sS9feUo0sZ3QABY,2825
+fabricatio/models/extra/article_main.py,sha256=0Xj54pRxUw5Iaj9npYmHKT-ZMvEIBlZ6G1ysNJRgceM,8225
+fabricatio/models/extra/article_outline.py,sha256=jFbVgiwlo7rnwCGS6ToVgeMUOoRe99Edgbx95THR6z8,1450
+fabricatio/models/extra/article_proposal.py,sha256=L2kPvH1XCCQSNcI1KQU3ULGq7C24Y88ssugX43LgbsE,2043
+fabricatio/models/extra/patches.py,sha256=-nBsse7g1astJh_IWZLXJdEQxpRla-DkHWqSHE-zbMU,989
+fabricatio/models/extra/problem.py,sha256=KwYkc7kjoEG7cwj9C8sWLoZgtBqJVuxlU_7KkvtSgO0,5828
+fabricatio/models/extra/rule.py,sha256=SDAPub17OzVJlPby358MQpKCyxmmojWucfuyr5zogeI,2091
+fabricatio/models/extra/__init__.py,sha256=XlYnS_2B9nhLhtQkjE7rvvfPmAAtXVdNi9bSDAR-Ge8,54
+fabricatio/models/generic.py,sha256=ioofSuSxJrgij6ZwucCV7RkVEU9XkW3C359k7s8ZhPA,28274
+fabricatio/models/kwargs_types.py,sha256=sMDA85SoC1AOJ5k6qC8qUiUv0Ne0_5ThU9FZITRNen4,5673
+fabricatio/models/role.py,sha256=-CRcj5_M3_ciLPzwiNn92grBmwoSLQ-n4koVZiCNTBM,2953
+fabricatio/models/task.py,sha256=YXvO3upJkTqMQjPgUGfp0bIiSyZzek2f4IagHdMW5Ik,10491
+fabricatio/models/tool.py,sha256=jQ51g4lwTPfsMF1nbreDJtBczbxIHoXcPuLSOqHliq8,12506
+fabricatio/models/usages.py,sha256=atMrA1MlPthpKYjV5lIrvJwe-BFomOQXQAWAS85YFqw,32319
+fabricatio/models/utils.py,sha256=Ac5g-8ic6q_w7dhNuh-iiofpL1sqOACxbjPPTljP2LY,4417
+fabricatio/parser.py,sha256=UOSvXigEXK-eXsr3m3b7glOhbBWs4kDJTeTNyuqA9ic,6315
+fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio/rust.pyi,sha256=_N8Jw1DMOFAaoibSQolxkKZ07nCfJao7Z9qkojHtLy0,5104
+fabricatio/rust_instances.py,sha256=Byeo8KHW_dJiXujJq7YPGDLBX5bHNDYbBc4sY3uubVY,313
+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/utils.py,sha256=QJR00IuclL2nNTSfpTNBRYJmNjc_DNXGtrYWjatWpq8,1681
+fabricatio/workflows/articles.py,sha256=G5HGRr-DHuYuEcfhFdFAuDvTTJ9aSU_UQ2yYXEjTMtM,1047
+fabricatio/workflows/rag.py,sha256=-YYp2tlE9Vtfgpg6ROpu6QVO8j8yVSPa6yDzlN3qVxs,520
+fabricatio/workflows/__init__.py,sha256=5ScFSTA-bvhCesj3U9Mnmi6Law6N1fmh5UKyh58L3u8,51
+fabricatio/__init__.py,sha256=Rmvq2VgdS2u68vnOi2i5RbeWbAwrJDbk8D8D883PJWE,1022
+fabricatio/rust.cp312-win_amd64.pyd,sha256=zttODmJfFoJUea2oaoWsbQK9u1wsQFCZXvLmlaFouts,1896960
+fabricatio-0.2.9.dev0.data/scripts/tdown.exe,sha256=hAuKtjV8oj1fsMlF6_2W5Asc8tgsPFVPSQhcBPzKnFM,3395072
+fabricatio-0.2.9.dev0.dist-info/RECORD,,