fabricatio 0.2.0.dev16__tar.gz → 0.2.0.dev18__tar.gz

{fabricatio-0.2.0.dev16 → fabricatio-0.2.0.dev18}/PKG-INFO

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

{fabricatio-0.2.0.dev16 → fabricatio-0.2.0.dev18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.0-dev.16"
+version = "0.2.0-dev.18"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -47,6 +47,8 @@ dependencies = [
 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"
@@ -59,6 +61,9 @@ data = "extra"
 dev = [
     "maturin>=1.8.2",
     "maturin-import-hook>=0.2.0",
+    "ruff>=0.9.4",
+    "uv>=0.5.29",
+    "viztracer>=1.0.2",
     "pytest>=8.3.4",
     "pytest-asyncio>=0.25.3",
     "pytest-cov>=6.0.0",
@@ -67,10 +72,9 @@ dev = [
     "pytest-mock>=3.14.0",
     "pytest-rerunfailures>=15.0",
     "pytest-xdist>=3.6.1",
-    "ruff>=0.9.4",
-    "uv>=0.5.29",
-    "viztracer>=1.0.2",
 ]
+
+[project.optional-dependencies]
 rag = [
     "faiss-cpu>=1.10.0",
     "pymilvus>=2.5.4",
@@ -80,7 +84,6 @@ full = [
     "fabricatio[rag]",
 ]
 
-
 [tool.ruff]
 include = ["pyproject.toml", "python/fabricatio/*.py","python/fabricatio/*.pyi", "examples/*.py"]
 line-length = 120
@@ -136,7 +139,7 @@ testpaths = [
 ]
 
 [tool.uv.sources]
-code2prompt = { git = "https://github.com/mufeedvh/code2prompt" }
+code2prompt = { git = "https://github.com/mufeedvh/code2prompt", rev = "d157ee84827458bd6816142e213886487d28bd3d" }
 
 [[tool.uv.index]]
 url = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"

fabricatio-0.2.0.dev18/python/fabricatio/models/advanced.py

@@ -0,0 +1,119 @@
+"""A module for advanced models and functionalities."""
+
+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, PythonCapture
+from loguru import logger
+from pydantic import PositiveInt, ValidationError
+
+
+class ProposeTask(LLMUsage, WithBriefing):
+    """A class that proposes a task based on a prompt."""
+
+    async def propose(
+        self,
+        prompt: str,
+        max_validations: PositiveInt = 2,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> Task:
+        """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.
+            **kwargs: The keyword arguments for the LLM (Large Language Model) usage.
+
+        Returns:
+            A Task object based on the proposal result.
+        """
+        if not prompt:
+            err = f"{self.name}: Prompt must be provided."
+            logger.error(err)
+            raise ValueError(err)
+
+        def _validate_json(response: str) -> None | Task:
+            try:
+                cap = JsonCapture.capture(response)
+                logger.debug(f"Response: \n{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
+
+        template_data = {"prompt": prompt, "json_example": Task.json_example()}
+        return await self.aask_validate(
+            question=template_manager.render_template("propose_task", template_data),
+            validator=_validate_json,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            max_validations=max_validations,
+            **kwargs,
+        )
+
+
+class HandleTask(WithBriefing, ToolBoxUsage):
+    """A class that handles a task based on a task object."""
+
+    async def draft_tool_usage_code(
+        self,
+        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(
+                "draft_tool_usage_code",
+                {
+                    "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."""
+        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-0.2.0.dev18/python/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-0.2.0.dev16 → fabricatio-0.2.0.dev18}/python/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-0.2.0.dev16 → fabricatio-0.2.0.dev18}/python/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."""
 
@@ -319,14 +307,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 +342,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 +376,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 +384,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 +411,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-0.2.0.dev16 → fabricatio-0.2.0.dev18}/python/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
 

fabricatio-0.2.0.dev18/templates/built-in/draft_tool_usage_code.hbs

@@ -0,0 +1,52 @@
+You are a developer tasked with writing Python code to use specific tools for a given task. Below is the task briefing and the briefings of the tools available. 
+
+**Task Briefing:**
+{{ task }}
+
+**Available Tools:**
+{{#each tools }}
+{{ this }}
+
+{{/each }}
+
+Please draft the Python code that uses these tools to accomplish the task. Ensure that the code is well-documented and follows best practices. The code should be executable and should include any necessary imports.
+Further, to ensure I can retrieve the execute result, you need to specify variable names that represent the output of your code. These variables should be named with JSON serializable values.
+
+
+**Response Format:**
+1. Provide the Python code as a codeblock.
+2. Ensure the code can be compiled and executed without errors.
+
+
+**Example Response:**
+
+----
+
+```python
+from {{tool_module_name}} import ({{#each tool_class_names }}
+    {{this}},
+{{/each }})
+
+# Your code here
+
+output1 = # Your output here
+output2 = # Your output here
+another_output = # Your output here
+
+
+```
+
+```json
+[
+    "output1",
+    "output2",
+    "another_output"
+]
+```
+
+----
+
+**Warning:**
+
+- No extra explanation is needed. Only the python code and the JSON array is required.
+- Do not include any imports that are not necessary for the code to run.

{fabricatio-0.2.0.dev16 → fabricatio-0.2.0.dev18}/uv.lock

@@ -179,7 +179,7 @@ wheels = [
 [[package]]
 name = "code2prompt"
 version = "2.0.0"
-source = { git = "https://github.com/mufeedvh/code2prompt#28bf1dc0f9b847a890045a2b0bb95a84aa54520b" }
+source = { git = "https://github.com/mufeedvh/code2prompt?rev=d157ee84827458bd6816142e213886487d28bd3d#d157ee84827458bd6816142e213886487d28bd3d" }
 
 [[package]]
 name = "colorama"
@@ -260,7 +260,7 @@ wheels = [
 
 [[package]]
 name = "fabricatio"
-version = "0.2.0.dev16"
+version = "0.2.0.dev18"
 source = { editable = "." }
 dependencies = [
     { name = "appdirs" },
@@ -279,6 +279,16 @@ dependencies = [
     { name = "rich" },
 ]
 
+[package.optional-dependencies]
+full = [
+    { name = "faiss-cpu" },
+    { name = "pymilvus" },
+]
+rag = [
+    { name = "faiss-cpu" },
+    { name = "pymilvus" },
+]
+
 [package.dev-dependencies]
 dev = [
     { name = "maturin" },
@@ -295,19 +305,14 @@ dev = [
     { name = "uv" },
     { name = "viztracer" },
 ]
-full = [
-    { name = "fabricatio" },
-]
-rag = [
-    { name = "faiss-cpu" },
-    { name = "pymilvus" },
-]
 
 [package.metadata]
 requires-dist = [
     { name = "appdirs", specifier = ">=1.4.4" },
     { name = "asyncio", specifier = ">=3.4.3" },
-    { name = "code2prompt", git = "https://github.com/mufeedvh/code2prompt" },
+    { name = "code2prompt", git = "https://github.com/mufeedvh/code2prompt?rev=d157ee84827458bd6816142e213886487d28bd3d" },
+    { name = "fabricatio", extras = ["rag"], marker = "extra == 'full'" },
+    { name = "faiss-cpu", marker = "extra == 'rag'", specifier = ">=1.10.0" },
     { name = "gitpython", specifier = ">=3.1.44" },
     { name = "litellm", specifier = ">=1.60.0" },
     { name = "loguru", specifier = ">=0.7.3" },
@@ -315,11 +320,13 @@ requires-dist = [
     { name = "orjson", specifier = ">=3.10.15" },
     { name = "pydantic", specifier = ">=2.10.6" },
     { name = "pydantic-settings", specifier = ">=2.7.1" },
+    { name = "pymilvus", marker = "extra == 'rag'", specifier = ">=2.5.4" },
     { name = "pymitter", specifier = ">=1.0.0" },
     { name = "questionary", specifier = ">=2.1.0" },
     { name = "regex", specifier = ">=2024.11.6" },
     { name = "rich", specifier = ">=13.9.4" },
 ]
+provides-extras = ["rag", "full"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -337,11 +344,6 @@ dev = [
     { name = "uv", specifier = ">=0.5.29" },
     { name = "viztracer", specifier = ">=1.0.2" },
 ]
-full = [{ name = "fabricatio", extras = ["rag"] }]
-rag = [
-    { name = "faiss-cpu", specifier = ">=1.10.0" },
-    { name = "pymilvus", specifier = ">=2.5.4" },
-]
 
 [[package]]
 name = "faiss-cpu"

fabricatio-0.2.0.dev16/python/fabricatio/models/advanced.py

@@ -1,96 +0,0 @@
-"""A module for advanced models and functionalities."""
-
-from typing import List
-
-from fabricatio._rust_instances import template_manager
-from fabricatio.models.generic import WithBriefing
-from fabricatio.models.task import Task
-from fabricatio.models.usages import LLMUsage, ToolBoxUsage
-from fabricatio.parser import JsonCapture
-from loguru import logger
-from pydantic import NonNegativeFloat, PositiveInt, ValidationError
-
-
-class ProposeTask(LLMUsage, WithBriefing):
-    """A class that proposes a task based on a prompt."""
-
-    async def propose(
-        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:
-        """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.
-
-        Returns:
-            A Task object based on the proposal result.
-        """
-        if not prompt:
-            err = f"{self.name}: Prompt must be provided."
-            logger.error(err)
-            raise ValueError(err)
-
-        def _validate_json(response: str) -> None | Task:
-            try:
-                cap = JsonCapture.capture(response)
-                logger.debug(f"Response: \n{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
-
-        template_data = {"prompt": prompt, "json_example": Task.json_example()}
-        return await self.aask_validate(
-            question=template_manager.render_template("propose_task", 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,
-        )
-
-
-class HandleTask(WithBriefing, ToolBoxUsage):
-    """A class that handles a task based on a task object."""
-
-    async def handle[T](
-        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:
-        """Asynchronously handles a task based on a given task object and parameters."""
-        # TODO: Implement the handle method