fabricatio 0.2.0.dev12__tar.gz → 0.2.0.dev14__tar.gz

{fabricatio-0.2.0.dev12 → fabricatio-0.2.0.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.0.dev12
+Version: 0.2.0.dev14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -28,6 +28,9 @@ Keywords: ai,agents,multi-agent,llm,pyo3
 Author-email: Whth <zettainspector@foxmail.com>
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/Whth/fabricatio
+Project-URL: Repository, https://github.com/Whth/fabricatio
+Project-URL: Issues, https://github.com/Whth/fabricatio/issues
 
 # Fabricatio
 

fabricatio-0.2.0.dev14/examples/propose_task/propose.py

@@ -0,0 +1,31 @@
+import asyncio
+from typing import Any
+
+from fabricatio import Action, Role, Task, WorkFlow, logger
+
+task = Task(name="say hello", goal="say hello", description="say hello to the world")
+
+
+class Talk(Action):
+    """Action that says hello to the world."""
+
+    name: str = "talk"
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **_) -> Any:
+        ret = "Hello fabricatio!"
+        logger.info("executing talk action")
+        return ret
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="talker", description="talker role", registry={task.pending_label: WorkFlow(name="talk", steps=(Talk,))}
+    )
+    logger.info(Task.json_example())
+    logger.info(f"proposed task: {await role.propose('write a rust clap cli that can download a html page')}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.0.dev12 → fabricatio-0.2.0.dev14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.0-dev.12"
+version = "0.2.0-dev.14"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -25,7 +25,6 @@ keywords = [
 ]
 
 
-
 requires-python = ">=3.12"
 dependencies = [
     "appdirs>=1.4.4",
@@ -44,7 +43,10 @@ dependencies = [
     "rich>=13.9.4",
 ]
 
-
+[project.urls]
+Homepage = "https://github.com/Whth/fabricatio"
+Repository = "https://github.com/Whth/fabricatio"
+Issues = "https://github.com/Whth/fabricatio/issues"
 [build-system]
 requires = ["maturin>=1.0,<2.0"]
 build-backend = "maturin"

{fabricatio-0.2.0.dev12 → fabricatio-0.2.0.dev14}/python/fabricatio/models/action.py

@@ -8,10 +8,11 @@ from typing import Any, Dict, Self, Tuple, Type, Unpack
 from fabricatio.journal import logger
 from fabricatio.models.generic import LLMUsage, WithBriefing
 from fabricatio.models.task import ProposeTask, Task
+from fabricatio.models.tool import ToolBoxUsage
 from pydantic import Field, PrivateAttr
 
 
-class Action(ProposeTask):
+class Action(ProposeTask, ToolBoxUsage):
     """Class that represents an action to be executed in a workflow."""
 
     personality: str = Field(default="")
@@ -50,7 +51,7 @@ class Action(ProposeTask):
         return f"# The action you are going to perform: \n{super().briefing}"
 
 
-class WorkFlow[A: Type[Action] | Action](WithBriefing, LLMUsage):
+class WorkFlow[A: Type[Action] | Action](WithBriefing, LLMUsage, ToolBoxUsage):
     """Class that represents a workflow to be executed in a task."""
 
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
@@ -121,7 +122,12 @@ class WorkFlow[A: Type[Action] | Action](WithBriefing, LLMUsage):
         logger.debug(f"Initializing context for workflow: {self.name}")
         await self._context.put({self.task_input_key: None, **dict(self.extra_init_context)})
 
-    def fallback_to_self(self) -> Self:
+    def steps_fallback_to_self(self) -> Self:
         """Set the fallback for each step to the workflow itself."""
         self.hold_to(self._instances)
         return self
+
+    def steps_supply_tools_from_self(self) -> Self:
+        """Supply the tools from the workflow to each step."""
+        self.provide_tools_to(self._instances)
+        return self

{fabricatio-0.2.0.dev12 → fabricatio-0.2.0.dev14}/python/fabricatio/models/generic.py

@@ -17,6 +17,7 @@ from pydantic import (
     Field,
     HttpUrl,
     NonNegativeFloat,
+    NonNegativeInt,
     PositiveInt,
     SecretStr,
 )
@@ -295,6 +296,7 @@ class LLMUsage(Base):
         self,
         instruction: str,
         choices: List[T],
+        k: NonNegativeInt = 0,
         max_validations: PositiveInt = 2,
         system_message: str = "",
         model: str | None = None,
@@ -311,6 +313,7 @@ class LLMUsage(Base):
         Args:
             instruction: The user-provided instruction/question description.
             choices: A list of candidate options, requiring elements to have `name` and `briefing` fields.
+            k: The number of choices to select, 0 means infinite.
             max_validations: Maximum number of validation failures, default is 2.
             system_message: Custom system-level prompt, defaults to an empty string.
             model: The name of the LLM model to use.
@@ -332,14 +335,17 @@ class LLMUsage(Base):
         """
         prompt = template_manager.render_template(
             "make_choice",
-            {"instruction": instruction, "options": [m.model_dump(include={"name", "briefing"}) for m in choices]},
+            {
+                "instruction": instruction,
+                "options": [m.model_dump(include={"name", "briefing"}) for m in choices],
+                "k": k,
+            },
         )
         names = [c.name for c in choices]
 
         def _validate(response: str) -> List[T] | None:
-            cap = JsonCapture.capture(response)
-            ret = orjson.loads(cap)
-            if not isinstance(ret, List):
+            ret = JsonCapture.convert_with(response, orjson.loads)
+            if not isinstance(ret, List) or len(ret) != k:
                 return None
             if any(n not in names for n in ret):
                 return None
@@ -360,6 +366,70 @@ class LLMUsage(Base):
             max_retries=max_retries,
         )
 
+    async def ajudge(
+        self,
+        prompt: str,
+        affirm_case: str = "",
+        deny_case: str = "",
+        max_validations: PositiveInt = 2,
+        system_message: str = "",
+        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,
+    ) -> bool:
+        """Asynchronously judges a prompt using AI validation.
+
+        Args:
+            prompt (str): The input prompt to be judged.
+            affirm_case (str, optional): The affirmative case for the AI model. Defaults to "".
+            deny_case (str, optional): The negative case for the AI model. Defaults to "".
+            max_validations (PositiveInt, optional): Maximum number of validation attempts. Defaults to 2.
+            system_message (str, optional): System message for the AI model. Defaults to "".
+            model (str | None, optional): AI model to use. Defaults to None.
+            temperature (NonNegativeFloat | None, optional): Sampling temperature. Defaults to None.
+            stop (str | List[str] | None, optional): Stop sequences. Defaults to None.
+            top_p (NonNegativeFloat | None, optional): Nucleus sampling parameter. Defaults to None.
+            max_tokens (PositiveInt | None, optional): Maximum number of tokens to generate. Defaults to None.
+            stream (bool | None, optional): Whether to stream the response. Defaults to None.
+            timeout (PositiveInt | None, optional): Timeout in seconds. Defaults to None.
+            max_retries (PositiveInt | None, optional): Maximum number of retries. Defaults to None.
+
+        Returns:
+            bool: The judgment result (True or False) based on the AI's response.
+
+        Notes:
+            The method uses an internal validator to ensure the response is a boolean value.
+            If the response cannot be converted to a boolean, it will return None.
+        """
+
+        def _validate(response: str) -> bool | None:
+            ret = JsonCapture.convert_with(response, orjson.loads)
+            if not isinstance(ret, bool):
+                return None
+            return ret
+
+        return await self.aask_validate(
+            question=template_manager.render_template(
+                "make_judgment", {"prompt": prompt, "affirm_case": affirm_case, "deny_case": deny_case}
+            ),
+            validator=_validate,
+            max_validations=max_validations,
+            system_message=system_message,
+            model=model,
+            temperature=temperature,
+            stop=stop,
+            top_p=top_p,
+            max_tokens=max_tokens,
+            stream=stream,
+            timeout=timeout,
+            max_retries=max_retries,
+        )
+
     def fallback_to(self, other: "LLMUsage") -> Self:
         """Fallback to another instance's attribute values if the current instance's attributes are None.
 

{fabricatio-0.2.0.dev12 → fabricatio-0.2.0.dev14}/python/fabricatio/models/role.py

@@ -1,25 +1,36 @@
 """Module that contains the Role class."""
 
-from typing import Any
+from typing import Any, Set
 
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.action import WorkFlow
 from fabricatio.models.events import Event
 from fabricatio.models.task import ProposeTask
+from fabricatio.models.tool import ToolBox, ToolBoxUsage
+from fabricatio.toolboxes import basic_toolboxes
 from pydantic import Field
 
 
-class Role(ProposeTask):
+class Role(ProposeTask, ToolBoxUsage):
     """Class that represents a role with a registry of events and workflows."""
 
     registry: dict[Event | str, WorkFlow] = Field(...)
     """ The registry of events and workflows."""
 
+    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."""
         for event, workflow in self.registry.items():
-            workflow.fallback_to(self).fallback_to_self().inject_personality(self.briefing)
+            (
+                workflow.fallback_to(self)
+                .steps_fallback_to_self()
+                .inject_personality(self.briefing)
+                .supply_tools_from(self)
+                .steps_supply_tools_from_self()
+            )
+
             logger.debug(
                 f"Registering workflow: {workflow.name} for event: {event.collapse() if isinstance(event, Event) else event}"
             )

{fabricatio-0.2.0.dev12 → fabricatio-0.2.0.dev14}/python/fabricatio/models/task.py

@@ -268,8 +268,8 @@ class ProposeTask(LLMUsage, WithBriefing):
             try:
                 cap = JsonCapture.capture(response)
                 logger.debug(f"Response: \n{response}")
-                logger.info(f"Captured JSON: \n{cap[0]}")
-                return Task.model_validate_json(cap[0] if cap else response)
+                logger.info(f"Captured JSON: \n{cap}")
+                return Task.model_validate_json(cap)
             except ValidationError as e:
                 logger.error(f"Failed to parse task from JSON: {e}")
                 return None

{fabricatio-0.2.0.dev12 → fabricatio-0.2.0.dev14}/python/fabricatio/models/tool.py

@@ -1,8 +1,9 @@
 """A module for defining tools and toolboxes."""
 
 from inspect import iscoroutinefunction, signature
-from typing import Any, Callable, Iterable, List, Optional, Self, Union
+from typing import Any, Callable, Iterable, List, Self, Set, Union
 
+from fabricatio.journal import logger
 from fabricatio.models.generic import Base, WithBriefing
 from pydantic import Field
 
@@ -28,6 +29,7 @@ class Tool[**P, R](WithBriefing):
 
     def invoke(self, *args: P.args, **kwargs: P.kwargs) -> R:
         """Invoke the tool's source function with the provided arguments."""
+        logger.info(f"Invoking tool: {self.name} with args: {args} and kwargs: {kwargs}")
         return self.source(*args, **kwargs)
 
     @property
@@ -105,14 +107,23 @@ class ToolBox(WithBriefing):
         assert tool, f"No tool named {name} found."
         return tool
 
+    def __hash__(self) -> int:
+        """Return a hash of the toolbox based on its briefing."""
+        return hash(self.briefing)
 
-class ToolUsage(Base):
+
+class ToolBoxUsage(Base):
     """A class representing the usage of tools in a task."""
 
-    toolboxes: Optional[List[ToolBox]]
-    """The tools used by the task, a list of ToolBox instances."""
+    toolboxes: Set[ToolBox] = Field(default_factory=set)
+    """A set of toolboxes used by the instance."""
+
+    @property
+    def available_toolbox_names(self) -> List[str]:
+        """Return a list of available toolbox names."""
+        return [toolbox.name for toolbox in self.toolboxes]
 
-    def supply_tools_from(self, others: Union["ToolUsage", Iterable["ToolUsage"]]) -> Self:
+    def supply_tools_from(self, others: Union["ToolBoxUsage", Iterable["ToolBoxUsage"]]) -> Self:
         """Supplies tools from other ToolUsage instances to this instance.
 
         Args:
@@ -122,13 +133,13 @@ class ToolUsage(Base):
         Returns:
             Self: The current ToolUsage instance with updated tools.
         """
-        if isinstance(others, ToolUsage):
+        if isinstance(others, ToolBoxUsage):
             others = [others]
         for other in others:
-            self.toolboxes.extend(other.toolboxes)
+            self.toolboxes.update(other.toolboxes)
         return self
 
-    def provide_tools_to(self, others: Union["ToolUsage", Iterable["ToolUsage"]]) -> Self:
+    def provide_tools_to(self, others: Union["ToolBoxUsage", Iterable["ToolBoxUsage"]]) -> Self:
         """Provides tools from this instance to other ToolUsage instances.
 
         Args:
@@ -138,8 +149,8 @@ class ToolUsage(Base):
         Returns:
             Self: The current ToolUsage instance.
         """
-        if isinstance(others, ToolUsage):
+        if isinstance(others, ToolBoxUsage):
             others = [others]
         for other in others:
-            other.toolboxes.extend(self.toolboxes)
+            other.toolboxes.update(self.toolboxes)
         return self

{fabricatio-0.2.0.dev12 → fabricatio-0.2.0.dev14}/python/fabricatio/parser.py

@@ -1,11 +1,13 @@
 """A module to parse text using regular expressions."""
 
-from typing import Any, Self, Tuple
+from typing import Any, Callable, Self, Tuple
 
 import regex
 from pydantic import BaseModel, ConfigDict, Field, PositiveInt, PrivateAttr
 from regex import Pattern, compile
 
+from fabricatio.journal import logger
+
 
 class Capture(BaseModel):
     """A class to capture patterns in text using regular expressions.
@@ -32,7 +34,7 @@ class Capture(BaseModel):
         """
         self._compiled = compile(self.pattern, self.flags)
 
-    def capture(self, text: str) -> Tuple[str, ...] | None:
+    def capture(self, text: str) -> Tuple[str, ...] | str | None:
         """Capture the first occurrence of the pattern in the given text.
 
         Args:
@@ -48,7 +50,25 @@ class Capture(BaseModel):
 
         if self.target_groups:
             return tuple(match.group(g) for g in self.target_groups)
-        return (match.group(),)
+        return match.group(1)
+
+    def convert_with[T](self, text: str, convertor: Callable[[Tuple[str, ...]], T] | Callable[[str], T]) -> T | None:
+        """Convert the given text using the pattern.
+
+        Args:
+            text (str): The text to search the pattern in.
+            convertor (Callable[[Tuple[str, ...]], T] | Callable[[str], T]): The function to convert the captured text.
+
+        Returns:
+            str | None: The converted text if the pattern is found, otherwise None.
+        """
+        if cap := self.capture(text) is None:
+            return None
+        try:
+            return convertor(cap)
+        except ValueError as e:
+            logger.error(f"Failed to convert text using convertor: {convertor.__name__}, error: \n{e}")
+            return None
 
     @classmethod
     def capture_code_block(cls, language: str) -> Self:
@@ -60,7 +80,7 @@ class Capture(BaseModel):
         Returns:
             Self: The instance of the class with the captured code block.
         """
-        return cls(pattern=f"```{language}\n(.*?)\n```", target_groups=(1,))
+        return cls(pattern=f"```{language}\n(.*?)\n```")
 
 
 JsonCapture = Capture.capture_code_block("json")

fabricatio-0.2.0.dev14/python/fabricatio/toolboxes/__init__.py

@@ -0,0 +1,15 @@
+"""Contains the built-in toolboxes for the Fabricatio package."""
+
+from typing import Set
+
+from fabricatio.models.tool import ToolBox
+from fabricatio.toolboxes.arithmetic import arithmetic_toolbox
+from fabricatio.toolboxes.task import task_toolbox
+
+basic_toolboxes: Set[ToolBox] = {task_toolbox, arithmetic_toolbox}
+
+__all__ = [
+    "arithmetic_toolbox",
+    "basic_toolboxes",
+    "task_toolbox",
+]

{fabricatio-0.2.0.dev12 → fabricatio-0.2.0.dev14}/python/fabricatio/toolboxes/arithmetic.py

@@ -1,9 +1,11 @@
+"""Arithmetic tools for Fabricatio."""
+
 from fabricatio.models.tool import ToolBox
 
-arithmetic_tools = ToolBox(name="ArithmeticToolBox", description="A toolbox for arithmetic operations.")
+arithmetic_toolbox = ToolBox(name="ArithmeticToolBox", description="A toolbox for arithmetic operations.")
 
 
-@arithmetic_tools.collect_tool
+@arithmetic_toolbox.collect_tool
 def add(a: float, b: float) -> float:
     """Add two numbers.
 
@@ -17,7 +19,7 @@ def add(a: float, b: float) -> float:
     return a + b
 
 
-@arithmetic_tools.collect_tool
+@arithmetic_toolbox.collect_tool
 def subtract(a: float, b: float) -> float:
     """Subtract two numbers.
 
@@ -31,7 +33,7 @@ def subtract(a: float, b: float) -> float:
     return a - b
 
 
-@arithmetic_tools.collect_tool
+@arithmetic_toolbox.collect_tool
 def multiply(a: float, b: float) -> float:
     """Multiply two numbers.
 
@@ -45,7 +47,7 @@ def multiply(a: float, b: float) -> float:
     return a * b
 
 
-@arithmetic_tools.collect_tool
+@arithmetic_toolbox.collect_tool
 def divide(a: float, b: float) -> float:
     """Divide two numbers.
 

fabricatio-0.2.0.dev14/python/fabricatio/toolboxes/task.py

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

{fabricatio-0.2.0.dev12 → fabricatio-0.2.0.dev14}/templates/built-in/make_choice.hbs

@@ -18,7 +18,9 @@ Example:
 ```json
 ["option1", "option2"]
 ```
+
 ### Warnings:
 
 Note that All items in list you returned **MUST** be contained in [{{#each options}}"{{name}}", {{/each}}], No extra items are allowed.
 Your response shall not have any explanation, only the JSON array of selected option names.
+{{#if k}}The array returned MUST have a length of **{{k}}**.{{/if}}

fabricatio-0.2.0.dev14/templates/built-in/make_judgment.hbs

@@ -0,0 +1,27 @@
+# Prompt:
+
+{{ prompt }}
+
+# Task:
+
+Please provide a boolean response (true or false) based on the prompt given above.:
+
+# Example:
+
+e.g. 1
+```json
+true
+```
+
+e.g. 2
+```json
+false
+```
+
+# Warnings:
+
+- Your response shall not have any explanation, only the boolean response.
+- Your response shall be either `true` or `false`.
+{{#if affirm_case}}- If {{affirm_case}}, respond `true`.{{/if}}
+{{#if deny_case}}- If {{deny_case}}, respond `false`.{{/if}}
+

{fabricatio-0.2.0.dev12 → fabricatio-0.2.0.dev14}/uv.lock

@@ -260,7 +260,7 @@ wheels = [
 
 [[package]]
 name = "fabricatio"
-version = "0.2.0.dev12"
+version = "0.2.0.dev14"
 source = { editable = "." }
 dependencies = [
     { name = "appdirs" },

fabricatio-0.2.0.dev12/python/fabricatio/toolboxes/__init__.py

@@ -1,7 +0,0 @@
-"""Contains the built-in toolboxes for the Fabricatio package."""
-
-from fabricatio.toolboxes.task import TaskToolBox
-
-__all__ = [
-    "TaskToolBox",
-]

fabricatio-0.2.0.dev12/python/fabricatio/toolboxes/task.py

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