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

fabricatio/__init__.py

@@ -11,6 +11,7 @@ from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
 from fabricatio.models.utils import Message, Messages
 from fabricatio.parser import Capture, CodeBlockCapture, JsonCapture, PythonCapture
+from fabricatio.toolboxes import arithmetic_toolbox, basic_toolboxes, fs_toolbox, task_toolbox
 
 __all__ = [
     "Action",
@@ -25,8 +26,12 @@ __all__ = [
     "Task",
     "ToolBox",
     "WorkFlow",
+    "arithmetic_toolbox",
+    "basic_toolboxes",
     "env",
+    "fs_toolbox",
     "logger",
     "magika",
+    "task_toolbox",
     "template_manager",
 ]

fabricatio/_rust.pyi

@@ -1,53 +1,53 @@
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Dict, List, Optional
 
 class TemplateManager:
-    def __init__(self, template_dirs: List[Path], suffix: Optional[str] = None) -> None:
+    """TemplateManager class for managing handlebars templates."""
+    def __init__(
+        self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
+    ) -> None:
         """Initialize the template manager.
 
         Args:
             template_dirs (List[Path]): A list of paths to directories containing templates.
-            suffix (str, optional): The suffix of template files. None means 'hbs' suffix .
+            suffix (str, optional): The suffix of template files. None means 'hbs' suffix.
+            active_loading (bool, optional): Whether to enable active loading of templates.
         """
 
     @property
     def template_count(self) -> int:
         """Get the number of templates discovered."""
 
-    @property
-    def templates(self) -> List[str]:
-        """Get a list of template names."""
-
-    def get_template(self, name: str) -> str:
-        """Get a template by name.
-
-        Args:
-            name (str): The name of the template to retrieve.
-
-        Returns:
-            str: The template content.
-        """
-
-    def get_template_source(self, name: str) -> str:
+    def get_template_source(self, name: str) -> Optional[str]:
         """Get the source path of a template by name.
 
         Args:
             name (str): The name of the template to retrieve.
 
         Returns:
-            str: The source path of the template.
+            Optional[str]: The source path of the template.
         """
 
     def discover_templates(self) -> None:
         """Discover templates in the specified directories."""
 
-    def render_template(self, name: str, data: Dict[str, Any]) -> str:
+    def render_template(self, name: str, data: Dict[str, str]) -> str:
         """Render a template with the given name and data.
 
         Args:
             name (str): The name of the template to render.
-            data (Dict[str, Any]): The data to pass to the template.
+            data (Dict[str, str]): The data to pass to the template.
 
         Returns:
             str: The rendered template.
         """
+
+def blake3_hash(content: bytes) -> str:
+    """Calculate the BLAKE3 hash of the given data.
+
+    Args:
+        content (bytes): The data to hash.
+
+    Returns:
+        str: The BLAKE3 hash of the data.
+    """

fabricatio/_rust_instances.py

@@ -1,4 +1,8 @@
 from fabricatio._rust import TemplateManager
 from fabricatio.config import configs
 
-template_manager = TemplateManager(template_dirs=configs.templates.template_dir, suffix=configs.templates.template_suffix)
+template_manager = TemplateManager(
+    template_dirs=configs.templates.template_dir,
+    suffix=configs.templates.template_suffix,
+    active_loading=configs.templates.active_loading,
+)

fabricatio/actions/communication.py

@@ -12,4 +12,4 @@ class Talk(Action):
 
     async def _execute(self, task_input: Task[str], **_) -> str:
         """Execute the action."""
-        return await self.aask(task_input.briefing, system_message=task_input.generate_prompt())
+        return await self.aask(task_input.briefing, system_message=task_input.dependencies_prompt())

fabricatio/config.py

@@ -63,7 +63,7 @@ class LLMConfig(BaseModel):
     temperature: NonNegativeFloat = Field(default=1.0)
     """The temperature of the LLM model. Controls randomness in generation. Set to 1.0 as per request."""
 
-    stop_sign: str | List[str] = Field(default=("\n\n", "User:"))
+    stop_sign: str | List[str] = Field(default=("\n\n\n", "User:"))
     """The stop sign of the LLM model. No default stop sign specified."""
 
     top_p: NonNegativeFloat = Field(default=0.35)
@@ -124,10 +124,27 @@ class TemplateConfig(BaseModel):
         default_factory=lambda: [DirectoryPath(r".\templates"), DirectoryPath(rf"{ROAMING_DIR}\templates")]
     )
     """The directory containing the templates."""
+    active_loading: bool = Field(default=False)
+    """Whether to enable active loading of templates."""
 
     template_suffix: str = Field(default="hbs", frozen=True)
     """The suffix of the templates."""
 
+    propose_task_template: str = Field(default="propose_task")
+    """The name of the propose task template which will be used to propose a task."""
+
+    draft_tool_usage_code_template: str = Field(default="draft_tool_usage_code")
+    """The name of the draft tool usage code template which will be used to draft tool usage code."""
+
+    make_choice_template: str = Field(default="make_choice")
+    """The name of the make choice template which will be used to make a choice."""
+
+    make_judgment_template: str = Field(default="make_judgment")
+    """The name of the make judgment template which will be used to make a judgment."""
+
+    dependencies_template: str = Field(default="dependencies")
+    """The name of the dependencies template which will be used to manage dependencies."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""

fabricatio/fs/curd.py

@@ -5,10 +5,11 @@ import subprocess
 from pathlib import Path
 from typing import Union
 
-from fabricatio.decorators import depend_on_external_cmd
+from fabricatio.decorators import confirm_to_execute, depend_on_external_cmd
 from fabricatio.journal import logger
 
 
+@confirm_to_execute
 def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
     """Copy a file from source to destination.
 
@@ -28,6 +29,7 @@ def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
         raise
 
 
+@confirm_to_execute
 def move_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
     """Move a file from source to destination.
 
@@ -47,6 +49,7 @@ def move_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
         raise
 
 
+@confirm_to_execute
 def delete_file(file_path: Union[str, Path]) -> None:
     """Delete a file.
 
@@ -65,6 +68,7 @@ def delete_file(file_path: Union[str, Path]) -> None:
         raise
 
 
+@confirm_to_execute
 def create_directory(dir_path: Union[str, Path], parents: bool = True, exist_ok: bool = True) -> None:
     """Create a directory.
 
@@ -81,6 +85,7 @@ def create_directory(dir_path: Union[str, Path], parents: bool = True, exist_ok:
         raise
 
 
+@confirm_to_execute
 @depend_on_external_cmd(
     "erd",
     "Please install `erd` using `cargo install erdtree` or `scoop install erdtree`.",
@@ -92,6 +97,7 @@ def tree(dir_path: Union[str, Path]) -> str:
     return subprocess.check_output(("erd", dir_path.as_posix()), encoding="utf-8")  # noqa: S603
 
 
+@confirm_to_execute
 def delete_directory(dir_path: Union[str, Path]) -> None:
     """Delete a directory and its contents.
 

fabricatio/fs/readers.py

@@ -1,7 +1,24 @@
 """Filesystem readers for Fabricatio."""
 
+from pathlib import Path
+
 from magika import Magika
 
 from fabricatio.config import configs
 
 magika = Magika(model_dir=configs.magika.model_dir)
+
+
+def safe_text_read(path: Path) -> str:
+    """Safely read the text from a file.
+
+    Args:
+        path (Path): The path to the file.
+
+    Returns:
+        str: The text from the file.
+    """
+    try:
+        return path.read_text(encoding="utf-8")
+    except (UnicodeDecodeError, IsADirectoryError, FileNotFoundError):
+        return ""

fabricatio/models/action.py

@@ -3,17 +3,17 @@
 import traceback
 from abc import abstractmethod
 from asyncio import Queue
-from typing import Any, Dict, Self, Tuple, Type, Unpack
+from typing import Any, Dict, Self, Tuple, Type, Union, Unpack
 
 from fabricatio.journal import logger
-from fabricatio.models.advanced import ProposeTask
+from fabricatio.models.advanced import HandleTask, ProposeTask
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.task import Task
 from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field, PrivateAttr
 
 
-class Action(ProposeTask, ToolBoxUsage):
+class Action(HandleTask, ProposeTask):
     """Class that represents an action to be executed in a workflow."""
 
     personality: str = Field(default="")
@@ -52,7 +52,7 @@ class Action(ProposeTask, ToolBoxUsage):
         return f"# The action you are going to perform: \n{super().briefing}"
 
 
-class WorkFlow[A: Type[Action] | Action](WithBriefing, ToolBoxUsage):
+class WorkFlow[A: Union[Type[Action], Action]](WithBriefing, ToolBoxUsage):
     """Class that represents a workflow to be executed in a task."""
 
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
@@ -102,13 +102,12 @@ class WorkFlow[A: Type[Action] | Action](WithBriefing, ToolBoxUsage):
             task: The task to be served.
         """
         await task.start()
-        await self._init_context()
+        await self._init_context(task)
         current_action = None
         try:
             for step in self._instances:
                 logger.debug(f"Executing step: {step.name}")
-                cxt = await self._context.get()
-                modified_ctx = await step.act(cxt)
+                modified_ctx = await step.act(await self._context.get())
                 await self._context.put(modified_ctx)
                 current_action = step.name
             logger.info(f"Finished executing workflow: {self.name}")
@@ -118,10 +117,10 @@ class WorkFlow[A: Type[Action] | Action](WithBriefing, ToolBoxUsage):
             logger.error(traceback.format_exc())  # Add this line to log the traceback
             await task.fail()  # Mark the task as failed
 
-    async def _init_context(self) -> None:
+    async def _init_context[T](self, task: Task[T]) -> None:
         """Initialize the context dictionary for workflow execution."""
         logger.debug(f"Initializing context for workflow: {self.name}")
-        await self._context.put({self.task_input_key: None, **dict(self.extra_init_context)})
+        await self._context.put({self.task_input_key: task, **dict(self.extra_init_context)})
 
     def steps_fallback_to_self(self) -> Self:
         """Set the fallback for each step to the workflow itself."""

fabricatio/models/advanced.py

@@ -1,45 +1,36 @@
 """A module for advanced models and functionalities."""
 
-from typing import List
+from types import CodeType
+from typing import List, Optional, Tuple, Unpack
 
+import orjson
 from fabricatio._rust_instances import template_manager
+from fabricatio.config import configs
 from fabricatio.models.generic import WithBriefing
+from fabricatio.models.kwargs_types import LLMKwargs
 from fabricatio.models.task import Task
+from fabricatio.models.tool import Tool, ToolExecutor
 from fabricatio.models.usages import LLMUsage, ToolBoxUsage
-from fabricatio.parser import JsonCapture
+from fabricatio.parser import JsonCapture, PythonCapture
 from loguru import logger
-from pydantic import NonNegativeFloat, PositiveInt, ValidationError
+from pydantic import PositiveInt, ValidationError
 
 
-class ProposeTask(LLMUsage, WithBriefing):
+class ProposeTask(WithBriefing, LLMUsage):
     """A class that proposes a task based on a prompt."""
 
-    async def propose(
+    async def propose[T](
         self,
         prompt: str,
         max_validations: PositiveInt = 2,
-        model: str | None = None,
-        temperature: NonNegativeFloat | None = None,
-        stop: str | List[str] | None = None,
-        top_p: NonNegativeFloat | None = None,
-        max_tokens: PositiveInt | None = None,
-        stream: bool | None = None,
-        timeout: PositiveInt | None = None,
-        max_retries: PositiveInt | None = None,
-    ) -> Task:
+        **kwargs: Unpack[LLMKwargs],
+    ) -> Task[T]:
         """Asynchronously proposes a task based on a given prompt and parameters.
 
         Parameters:
             prompt: The prompt text for proposing a task, which is a string that must be provided.
             max_validations: The maximum number of validations allowed, default is 2.
-            model: The model to be used, default is None.
-            temperature: The sampling temperature, default is None.
-            stop: The stop sequence(s) for generation, default is None.
-            top_p: The nucleus sampling parameter, default is None.
-            max_tokens: The maximum number of tokens to be generated, default is None.
-            stream: Whether to stream the output, default is None.
-            timeout: The timeout for the operation, default is None.
-            max_retries: The maximum number of retries for the operation, default is None.
+            **kwargs: The keyword arguments for the LLM (Large Language Model) usage.
 
         Returns:
             A Task object based on the proposal result.
@@ -61,36 +52,68 @@ class ProposeTask(LLMUsage, WithBriefing):
 
         template_data = {"prompt": prompt, "json_example": Task.json_example()}
         return await self.aask_validate(
-            question=template_manager.render_template("propose_task", template_data),
+            question=template_manager.render_template(configs.templates.propose_task_template, template_data),
             validator=_validate_json,
             system_message=f"# your personal briefing: \n{self.briefing}",
             max_validations=max_validations,
-            model=model,
-            temperature=temperature,
-            stop=stop,
-            top_p=top_p,
-            max_tokens=max_tokens,
-            stream=stream,
-            timeout=timeout,
-            max_retries=max_retries,
+            **kwargs,
         )
 
 
 class HandleTask(WithBriefing, ToolBoxUsage):
     """A class that handles a task based on a task object."""
 
-    async def handle[T](
+    async def draft_tool_usage_code(
         self,
-        task: Task[T],
-        max_validations: PositiveInt = 2,
-        model: str | None = None,
-        temperature: NonNegativeFloat | None = None,
-        stop: str | List[str] | None = None,
-        top_p: NonNegativeFloat | None = None,
-        max_tokens: PositiveInt | None = None,
-        stream: bool | None = None,
-        timeout: PositiveInt | None = None,
-        max_retries: PositiveInt | None = None,
-    ) -> T:
+        task: Task,
+        tools: List[Tool],
+        **kwargs: Unpack[LLMKwargs],
+    ) -> Tuple[CodeType, List[str]]:
+        """Asynchronously drafts the tool usage code for a task based on a given task object and tools."""
+        logger.info(f"Drafting tool usage code for task: {task.briefing}")
+
+        if not tools:
+            err = f"{self.name}: Tools must be provided to draft the tool usage code."
+            logger.error(err)
+            raise ValueError(err)
+
+        def _validator(response: str) -> Tuple[CodeType, List[str]] | None:
+            if (source := PythonCapture.convert_with(response, lambda resp: compile(resp, "<string>", "exec"))) and (
+                to_extract := JsonCapture.convert_with(response, orjson.loads)
+            ):
+                return source, to_extract
+            return None
+
+        return await self.aask_validate(
+            question=template_manager.render_template(
+                configs.templates.draft_tool_usage_code_template,
+                {
+                    "tool_module_name": configs.toolbox.tool_module_name,
+                    "task": task.briefing,
+                    "tools": [tool.briefing for tool in tools],
+                },
+            ),
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )
+
+    async def handle_fin_grind(
+        self,
+        task: Task,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> Optional[Tuple]:
         """Asynchronously handles a task based on a given task object and parameters."""
-        # TODO: Implement the handle method
+        logger.info(f"Handling task: {task.briefing}")
+
+        tools = await self.gather_tools(task)
+        logger.info(f"{self.name} have gathered {len(tools)} tools gathered")
+
+        if tools:
+            executor = ToolExecutor(execute_sequence=tools)
+            code, to_extract = await self.draft_tool_usage_code(task, tools, **kwargs)
+            cxt = await executor.execute(code)
+            if to_extract:
+                return tuple(cxt.get(k) for k in to_extract)
+
+        return None

fabricatio/models/events.py

@@ -1,11 +1,11 @@
 """The module containing the Event class."""
 
-from typing import List, Self
+from typing import List, Self, Union
 
 from fabricatio.config import configs
 from pydantic import BaseModel, ConfigDict, Field
 
-type EventLike = str | List[str] | Self
+type EventLike = Union[str, List[str], "Event"]
 
 
 class Event(BaseModel):

fabricatio/models/generic.py

@@ -4,7 +4,10 @@ from pathlib import Path
 from typing import List, Self
 
 import orjson
-from fabricatio.fs.readers import magika
+from fabricatio._rust import blake3_hash
+from fabricatio._rust_instances import template_manager
+from fabricatio.config import configs
+from fabricatio.fs.readers import magika, safe_text_read
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -96,15 +99,25 @@ class WithDependency(Base):
             self.dependencies.remove(Path(d).as_posix())
         return self
 
-    def generate_prompt(self) -> str:
+    @property
+    def dependencies_prompt(self) -> str:
         """Generate a prompt for the task based on the file dependencies.
 
         Returns:
             str: The generated prompt for the task.
         """
-        contents = [Path(d).read_text("utf-8") for d in self.dependencies]
-        recognized = [magika.identify_path(c) for c in contents]
-        out = ""
-        for r, p, c in zip(recognized, self.dependencies, contents, strict=False):
-            out += f"---\n\n> {p}\n```{r.dl.ct_label}\n{c}\n```\n\n"
-        return out
+        return template_manager.render_template(
+            configs.templates.dependencies_template,
+            {
+                (pth := Path(p)).as_posix(): {
+                    "exists": pth.exists(),
+                    "description": (identity := magika.identify_path(pth)).output.description,
+                    "size": f"{pth.stat().st_size / (1024 * 1024) if pth.exists() and pth.is_file() else 0:.3f} MB",
+                    "content": (text := safe_text_read(pth)),
+                    "lines": len(text.splitlines()),
+                    "language": identity.output.ct_label,
+                    "checksum": blake3_hash(pth.read_bytes()) if pth.exists() and pth.is_file() else "unknown",
+                }
+                for p in self.dependencies
+            },
+        )

fabricatio/models/kwargs_types.py

@@ -0,0 +1,26 @@
+"""This module contains the types for the keyword arguments of the methods in the models module."""
+
+from typing import List, NotRequired, TypedDict
+
+from pydantic import NonNegativeFloat, NonNegativeInt, PositiveInt
+
+
+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 ChooseKwargs(LLMKwargs):
+    """A type representing the keyword arguments for the choose method."""
+
+    max_validations: NotRequired[PositiveInt]
+    system_message: NotRequired[str]
+    k: NotRequired[NonNegativeInt]

fabricatio/models/role.py

@@ -1,6 +1,6 @@
 """Module that contains the Role class."""
 
-from typing import Any, Set
+from typing import Any, Self, Set
 
 from fabricatio.core import env
 from fabricatio.journal import logger
@@ -22,8 +22,22 @@ class Role(ProposeTask, ToolBoxUsage):
     toolboxes: Set[ToolBox] = Field(default=basic_toolboxes)
 
     def model_post_init(self, __context: Any) -> None:
+        """Register the workflows in the role to the event bus."""
+        self.resolve_configuration().register_workflows()
+
+    def register_workflows(self) -> Self:
         """Register the workflows in the role to the event bus."""
         for event, workflow in self.registry.items():
+            logger.debug(
+                f"Registering workflow: `{workflow.name}` for event: `{Event.instantiate_from(event).collapse()}`"
+            )
+            env.on(event, workflow.serve)
+        return self
+
+    def resolve_configuration(self) -> Self:
+        """Resolve the configuration of the role."""
+        for workflow in self.registry.values():
+            logger.debug(f"Resolving config for workflow: `{workflow.name}`")
             (
                 workflow.fallback_to(self)
                 .steps_fallback_to_self()
@@ -32,7 +46,4 @@ class Role(ProposeTask, ToolBoxUsage):
                 .steps_supply_tools_from_self()
             )
 
-            logger.debug(
-                f"Registering workflow: {workflow.name} for event: {event.collapse() if isinstance(event, Event) else event}"
-            )
-            env.on(event, workflow.serve)
+        return self

fabricatio/models/task.py

@@ -72,13 +72,28 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         """Move the task to a new namespace.
 
         Args:
-            new_namespace (List[str]): The new namespace to move the task to.
+            new_namespace (EventLike): The new namespace to move the task to.
 
         Returns:
             Task: The moved instance of the `Task` class.
         """
-        self.namespace = new_namespace
+        logger.debug(f"Moving task `{self.name}` to `{new_namespace}`")
         self._namespace.clear().concat(new_namespace)
+        self.namespace = self._namespace.segments
+        return self
+
+    def nested_move_to(self, new_parent_namespace: EventLike) -> Self:
+        """Move the task to a new namespace by nesting it under the new parent namespace.
+
+        Args:
+            new_parent_namespace (EventLike): The new parent namespace to move the task to.
+
+        Returns:
+            Task: The nested moved instance of the `Task` class.
+        """
+        logger.debug(f"Nested moving task `{self.name}` to `{new_parent_namespace}`")
+        self._namespace.clear().concat(new_parent_namespace).concat(self.namespace)
+        self.namespace = self._namespace.segments
         return self
 
     @classmethod
@@ -231,8 +246,8 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         Returns:
             Task: The published instance of the `Task` class
         """
-        logger.info(f"Publishing task {self.name}")
-        await env.emit_async(self.pending_label, self)
+        logger.info(f"Publishing task `{(label := self.pending_label)}`")
+        await env.emit_async(label, self)
         return self
 
     async def delegate(self) -> T:
@@ -241,8 +256,8 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         Returns:
             T: The output of the task
         """
-        logger.info(f"Delegating task {self.name}")
-        await env.emit_async(self.pending_label, self)
+        logger.info(f"Delegating task `{(label := self.pending_label)}`")
+        await env.emit_async(label, self)
         return await self.get_output()
 
     @property

fabricatio/models/tool.py

@@ -167,6 +167,6 @@ class ToolExecutor(BaseModel):
         tools = []
         while tool_name := recipe.pop(0):
             for toolbox in toolboxes:
-                tools.append(toolbox.get(tool_name))
+                tools.append(toolbox[tool_name])
 
         return cls(execute_sequence=tools)

fabricatio/models/usages.py

@@ -1,6 +1,6 @@
 """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
+from typing import Callable, Dict, Iterable, List, Optional, Self, Set, Union, Unpack
 
 import litellm
 import orjson
@@ -8,6 +8,7 @@ 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.kwargs_types import ChooseKwargs, LLMKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
 from fabricatio.models.utils import Messages
@@ -16,19 +17,6 @@ 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."""
 
@@ -177,7 +165,7 @@ class LLMUsage(Base):
         Raises:
             ValueError: If the response fails to validate after the maximum number of attempts.
         """
-        for _ in range(max_validations):
+        for i in range(max_validations):
             if (
                 response := await self.aask(
                     question=question,
@@ -185,7 +173,10 @@ class LLMUsage(Base):
                     **kwargs,
                 )
             ) and (validated := validator(response)):
+                logger.debug(f"Successfully validated the response at {i}th attempt. response: \n{response}")
                 return validated
+            logger.debug(f"Failed to validate the response at {i}th attempt. response: \n{response}")
+        logger.error(f"Failed to validate the response after {max_validations} attempts.")
         raise ValueError("Failed to validate the response.")
 
     async def achoose[T: WithBriefing](
@@ -216,7 +207,7 @@ class LLMUsage(Base):
             - Relies on `aask_validate` to implement retry mechanisms with validation.
         """
         prompt = template_manager.render_template(
-            "make_choice",
+            configs.templates.make_choice_template,
             {
                 "instruction": instruction,
                 "options": [m.model_dump(include={"name", "briefing"}) for m in choices],
@@ -276,7 +267,8 @@ class LLMUsage(Base):
 
         return await self.aask_validate(
             question=template_manager.render_template(
-                "make_judgment", {"prompt": prompt, "affirm_case": affirm_case, "deny_case": deny_case}
+                configs.templates.make_judgment_template,
+                {"prompt": prompt, "affirm_case": affirm_case, "deny_case": deny_case},
             ),
             validator=_validate,
             max_validations=max_validations,
@@ -319,14 +311,6 @@ class LLMUsage(Base):
                     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."""
 
@@ -362,7 +346,7 @@ class ToolBoxUsage(LLMUsage):
             logger.warning("No toolboxes available.")
             return []
         return await self.achoose(
-            instruction=task.briefing,
+            instruction=task.briefing,  # TODO write a template to build a more robust instruction
             choices=list(self.toolboxes),
             k=k,
             max_validations=max_validations,
@@ -396,7 +380,7 @@ class ToolBoxUsage(LLMUsage):
             logger.warning(f"No tools available in toolbox {toolbox.name}.")
             return []
         return await self.achoose(
-            instruction=task.briefing,
+            instruction=task.briefing,  # TODO write a template to build a more robust instruction
             choices=toolbox.tools,
             k=k,
             max_validations=max_validations,
@@ -404,7 +388,7 @@ class ToolBoxUsage(LLMUsage):
             **kwargs,
         )
 
-    async def gather_tools(
+    async def gather_tools_fine_grind(
         self,
         task: Task,
         box_choose_kwargs: Optional[ChooseKwargs] = None,
@@ -431,6 +415,18 @@ class ToolBoxUsage(LLMUsage):
             chosen_tools.extend(await self.choose_tools(task, toolbox, **tool_choose_kwargs))
         return chosen_tools
 
+    async def gather_tools(self, task: Task, **kwargs: Unpack[ChooseKwargs]) -> List[Tool]:
+        """Asynchronously gathers tools based on the provided task.
+
+        Args:
+            task (Task): The task for which to gather tools.
+            **kwargs (Unpack[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.
+        """
+        return await self.gather_tools_fine_grind(task, kwargs, kwargs)
+
     def supply_tools_from[S: "ToolBoxUsage"](self, others: Union[S, Iterable[S]]) -> Self:
         """Supplies tools from other ToolUsage instances to this instance.
 

fabricatio/parser.py

@@ -66,7 +66,7 @@ class Capture(BaseModel):
             return None
         try:
             return convertor(cap)
-        except ValueError as e:
+        except (ValueError, SyntaxError) as e:
             logger.error(f"Failed to convert text using convertor: {convertor.__name__}, error: \n{e}")
             return None
 
@@ -85,4 +85,5 @@ class Capture(BaseModel):
 
 JsonCapture = Capture.capture_code_block("json")
 PythonCapture = Capture.capture_code_block("python")
-CodeBlockCapture = Capture.capture_code_block("")
+MarkdownCapture = Capture.capture_code_block("markdown")
+CodeBlockCapture = Capture(pattern="```.*?\n(.*?)\n```")

fabricatio/toolboxes/__init__.py

@@ -4,6 +4,7 @@ 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}
@@ -11,5 +12,6 @@ basic_toolboxes: Set[ToolBox] = {task_toolbox, arithmetic_toolbox}
 __all__ = [
     "arithmetic_toolbox",
     "basic_toolboxes",
+    "fs_toolbox",
     "task_toolbox",
 ]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.0.dev17
+Version: 0.2.0.dev19
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

fabricatio-0.2.0.dev19.dist-info/RECORD

@@ -0,0 +1,35 @@
+fabricatio-0.2.0.dev19.dist-info/METADATA,sha256=ALJNEQ6R6ZRAKlAmf9sAaA_oy0DFRBAbpZjKUVSPLjQ,6386
+fabricatio-0.2.0.dev19.dist-info/WHEEL,sha256=tpW5AN9B-9qsM9WW2FXG2r193YXiqexDadpKp0A2daI,96
+fabricatio-0.2.0.dev19.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/communication.py,sha256=uNZY0YBJzWNPWjoKeX5Gks9MI4k9uOwjTuvkYzfm6ws,488
+fabricatio/actions/transmission.py,sha256=fU-xL8fDG3oRDD9x7Q94OU2Sb9G6xQfrj5IMlMYsgiM,1240
+fabricatio/actions/__init__.py,sha256=eFmFVPQvtNgFynIXBVr3eP-vWQDWCPng60YY5LXvZgg,115
+fabricatio/config.py,sha256=Qyb5jqRNjsuzc5gvNvciJ2rHOPF6tPDwPAeI3eC_EE4,9715
+fabricatio/core.py,sha256=yQK2ZrbPYDJOaNDp0Bky3muTkB-ZaQ1ld_Qfflm2dY0,5938
+fabricatio/decorators.py,sha256=XCnFmBoQMBB2rrJe58Kg8UP3lAyWwH9cGL7myh4FJNA,2630
+fabricatio/fs/curd.py,sha256=wBBAxZqTNdjLL5y0b61_YoAT9X0cQDhokrk96muqiA4,3569
+fabricatio/fs/readers.py,sha256=eDL9QhKEd6xfJBZaiwraObpGJWWpUd9NVYHoIvWgVqY,551
+fabricatio/fs/__init__.py,sha256=lWcKYg0v3mv2LnnSegOQaTtlVDODU0vtw_s6iKU5IqQ,122
+fabricatio/journal.py,sha256=z5K5waad9xmGr1hGrqSgFDRH3wiDQ5Oqfe0o98DaM-k,707
+fabricatio/models/action.py,sha256=fwAKhXqgkI1brRTsWuToUAF8CV4HfPDdutLjNcQ4oiU,5319
+fabricatio/models/advanced.py,sha256=VJJTWItMC-fDBdpJ7wx2tAlNq9NsXceexAb8AHZNL1E,4725
+fabricatio/models/events.py,sha256=mrihNEFgQ5o7qFWja1z_qX8dnaTLwPBoJdVlzxQV5oM,2719
+fabricatio/models/generic.py,sha256=s6E1CHwKZfZHnaq6p7f6H3-CI6tyIiGvd8-aoFv7D2w,4069
+fabricatio/models/kwargs_types.py,sha256=lSZAxOnhFdQwRkm-NrbJVMSyBbfdeuVNx807LvJpEOo,901
+fabricatio/models/role.py,sha256=Uqkqp06J3dSvrniGouonRA1ZRWjj8bKUGQwhuDq3b3A,1856
+fabricatio/models/task.py,sha256=vYZBGCc1g9wY66k9WGgDzXn7ZWrDNIRGiYKmOuIa2lQ,8908
+fabricatio/models/tool.py,sha256=mD0rlG7hpMxTd_pI6JfRxAVsqPaXGdw1VLThAlbrqFE,6385
+fabricatio/models/usages.py,sha256=QQcslV1ZaHEY3yBVctFqw1R1mtQLmzx48OJIh3qfONU,21093
+fabricatio/models/utils.py,sha256=i_kpcQpct04mQFk1nbcVGV-pl1YThWu4Qk3wbewzKkc,2535
+fabricatio/parser.py,sha256=R4dKANSacrt6StUWtlHyVVvFLivlXmdGD3v6HI62xh8,3358
+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=b13KmASO8q5fBLwew964fn9oH86ER5g-S1PgA4fZ_xs,482
+fabricatio/_rust.pyi,sha256=0kJ16N4fZ5rGMb4yo1rATD6z2GJf2C-V_wykjceVwp8,1751
+fabricatio/_rust_instances.py,sha256=dl0-yZ4UvT5g20tQgnPJpmqtkjFGXNG_YK4eLfi_ugQ,279
+fabricatio/__init__.py,sha256=opIrN8lGyT-h2If4Qez0bRuWBa3uIT9GsM9CZy7_XJ0,1100
+fabricatio/_rust.cp312-win_amd64.pyd,sha256=1tg7RZFBvzftLcwqx1Ef6Kb7u-4-n7Zzs8WU_JZqPvw,1261568
+fabricatio-0.2.0.dev19.data/scripts/tdown.exe,sha256=m3qWPWleaZk-_8XXQGCH8xrA5WPqn78Fts6ZnJ0OCCo,3378176
+fabricatio-0.2.0.dev19.dist-info/RECORD,,

fabricatio-0.2.0.dev17.dist-info/RECORD

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