fabricatio 0.2.1.dev1__tar.gz → 0.2.1.dev3__tar.gz

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/.gitignore

@@ -163,4 +163,5 @@ cython_debug/
 .idea/
 *playground*
 
-extra/scripts/*
+extra/scripts/*
+output/

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/PKG-INFO

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

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/examples/llm_usages/llm_usage.py

@@ -38,8 +38,10 @@ async def main() -> None:
         name="Coder",
         description="A python coder who can write code and documentation",
         registry={
-            Event.instantiate_from("coding.*").push("pending"): WorkFlow(name="write code", steps=(WriteCode,)),
-            Event.instantiate_from("doc.*").push("pending"): WorkFlow(
+            Event.instantiate_from("coding").push_wildcard().push("pending"): WorkFlow(
+                name="write code", steps=(WriteCode,)
+            ),
+            Event.instantiate_from("doc").push_wildcard().push("pending"): WorkFlow(
                 name="write documentation", steps=(WriteDocumentation,)
             ),
         },

fabricatio-0.2.1.dev3/examples/make_a_rating/rating.py

@@ -0,0 +1,84 @@
+"""Example of proposing a task to a role."""
+
+import asyncio
+from typing import Dict, List, Set, Unpack
+
+import orjson
+from fabricatio import Action, JsonCapture, Role, WorkFlow, logger
+from fabricatio.models.events import Event
+from fabricatio.models.task import Task
+
+
+class Rate(Action):
+    """Rate the task."""
+
+    name: str = "rate"
+    output_key: str = "task_output"
+
+    async def _execute(self, to_rate: List[str], rate_topic: str, dimensions: Set[str], **_) -> [Dict[str, float]]:
+        """Rate the task."""
+        return await asyncio.gather(
+            *[
+                self.rate(
+                    target,
+                    rate_topic,
+                    dimensions,
+                )
+                for target in to_rate
+            ]
+        )
+
+
+class WhatToRate(Action):
+    """Figure out what to rate."""
+
+    name: str = "figure out what to rate"
+
+    output_key: str = "to_rate"
+
+    async def _execute(self, task_input: Task, rate_topic: str, **cxt: Unpack) -> List[str]:
+        def _validate(resp: str) -> List[str] | None:
+            if (
+                (cap := JsonCapture.convert_with(resp, orjson.loads)) is not None
+                and isinstance(cap, list)
+                and all(isinstance(i, str) for i in cap)
+            ):
+                return cap
+            return None
+
+        return await self.aask_validate(
+            f"This is task briefing:\n{task_input.briefing}\n\n"
+            f"We are talking about {rate_topic}. you need to extract targets to rate into a the JSON array\n"
+            f"The response SHALL be a JSON array of strings within the codeblock\n"
+            f"# Example\n"
+            f'```json\n["this is a target to rate", "this is another target to rate"]\n```',
+            _validate,
+        )
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="TaskRater",
+        description="A role that can rate tasks.",
+        registry={
+            Event.instantiate_from("rate_food").push_wildcard().push("pending"): WorkFlow(
+                name="Rate food",
+                steps=(WhatToRate, Rate),
+                extra_init_context={
+                    "rate_topic": "If this food is cheap and delicious",
+                    "dimensions": {"taste", "price", "quality", "safety", "healthiness", "freshness"},
+                },
+            ),
+        },
+    )
+    task = await role.propose(
+        "rate for rotten apple, ripen banana, fresh orange, giga-burger, smelly pizza with flies on it, and a boiling instant coffee",
+    )
+    rating = await task.move_to("rate_food").delegate()
+
+    logger.success(f"Result: \n{rating}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/examples/minor/hello_fabricatio.py

@@ -5,7 +5,7 @@ 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")
+task = Task(name="say hello", goal=["say hello"], description="say hello to the world")
 
 
 class Hello(Action):

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/examples/propose_task/propose.py

@@ -5,7 +5,7 @@ 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")
+task = Task(name="say hello", goal=["say hello"], description="say hello to the world")
 
 
 class Talk(Action):

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/examples/simple_chat/chat.py

@@ -5,7 +5,7 @@ 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")
+task = Task(name="say hello", goal=["say hello"], description="say hello to the world")
 
 
 class Talk(Action):

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/examples/task_handle/handle_task.py

@@ -3,7 +3,6 @@
 import asyncio
 from typing import Any, Set, Unpack
 
-import questionary
 from fabricatio import Action, Event, PythonCapture, Role, Task, ToolBox, WorkFlow, fs_toolbox, logger
 from pydantic import Field
 
@@ -36,7 +35,7 @@ class DumpText(Action):
             ["dump the text contained in `text_to_dump` to a file", "only return the path of the written file"]
         )
 
-        path = await self.handle_fin_grind(
+        path = await self.handle(
             task_input,
             {"text_to_dump": dump_text},
         )
@@ -72,7 +71,7 @@ async def main() -> None:
         },
     )
 
-    prompt = await questionary.text("What code do you want to write?").ask_async()
+    prompt = "i want you to write a cli app implemented with python , which can calculate the sum to a given n, all write to a single file names `cli.py`, put it in `output` folder."
 
     proposed_task = await role.propose(prompt)
     path = await proposed_task.move_to("coding").delegate()

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.1-dev1"
+version = "0.2.1-dev3"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/python/fabricatio/config.py

@@ -157,6 +157,15 @@ class TemplateConfig(BaseModel):
     task_briefing_template: str = Field(default="task_briefing")
     """The name of the task briefing template which will be used to brief a task."""
 
+    rate_fine_grind_template: str = Field(default="rate_fine_grind")
+    """The name of the rate fine grind template which will be used to rate fine grind."""
+
+    draft_rating_manual_template: str = Field(default="draft_rating_manual")
+    """The name of the draft rating manual template which will be used to draft rating manual."""
+
+    draft_rating_dimensions_template: str = Field(default="draft_rating_dimensions")
+    """The name of the draft rating dimensions template which will be used to draft rating dimensions."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""
@@ -208,6 +217,7 @@ class Settings(BaseSettings):
         toml_file=["fabricatio.toml", rf"{ROAMING_DIR}\fabricatio.toml"],
         env_file=[".env", ".envrc"],
         use_attribute_docstrings=True,
+        extra="ignore",
     )
 
     llm: LLMConfig = Field(default_factory=LLMConfig)

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/python/fabricatio/models/action.py

@@ -6,14 +6,14 @@ from asyncio import Queue
 from typing import Any, Dict, Self, Tuple, Type, Union, Unpack
 
 from fabricatio.journal import logger
-from fabricatio.models.advanced import HandleTask, ProposeTask
+from fabricatio.models.advanced import GiveRating, 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(HandleTask, ProposeTask):
+class Action(HandleTask, ProposeTask, GiveRating):
     """Class that represents an action to be executed in a workflow."""
 
     personality: str = Field(default="")

fabricatio-0.2.1.dev3/python/fabricatio/models/advanced.py

@@ -0,0 +1,289 @@
+"""A module for advanced models and functionalities."""
+
+from types import CodeType
+from typing import Any, Dict, List, Optional, Set, 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 ChooseKwargs, ValidateKwargs
+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 NonNegativeInt, ValidationError
+
+
+class ProposeTask(WithBriefing, LLMUsage):
+    """A class that proposes a task based on a prompt."""
+
+    async def propose[T](
+        self,
+        prompt: str,
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> 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.
+            **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(configs.templates.propose_task_template, template_data),
+            validator=_validate_json,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **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],
+        data: Dict[str, Any],
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> 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
+
+        q = template_manager.render_template(
+            configs.templates.draft_tool_usage_code_template,
+            {
+                "data_module_name": configs.toolbox.data_module_name,
+                "tool_module_name": configs.toolbox.tool_module_name,
+                "task": task.briefing,
+                "deps": task.dependencies_prompt,
+                "tools": [{"name": t.name, "briefing": t.briefing} for t in tools],
+                "data": data,
+            },
+        )
+        logger.debug(f"Code Drafting Question: \n{q}")
+        return await self.aask_validate(
+            question=q,
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )
+
+    async def handle_fin_grind(
+        self,
+        task: Task,
+        data: Dict[str, Any],
+        box_choose_kwargs: Optional[ChooseKwargs] = None,
+        tool_choose_kwargs: Optional[ChooseKwargs] = None,
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Optional[Tuple]:
+        """Asynchronously handles a task based on a given task object and parameters."""
+        logger.info(f"Handling task: \n{task.briefing}")
+
+        tools = await self.gather_tools_fine_grind(task, box_choose_kwargs, tool_choose_kwargs)
+        logger.info(f"{self.name} have gathered {[t.name for t in tools]}")
+
+        if tools:
+            executor = ToolExecutor(candidates=tools, data=data)
+            code, to_extract = await self.draft_tool_usage_code(task, tools, data, **kwargs)
+
+            cxt = executor.execute(code)
+            if to_extract:
+                return tuple(cxt.get(k) for k in to_extract)
+
+        return None
+
+    async def handle(self, task: Task, data: Dict[str, Any], **kwargs: Unpack[ValidateKwargs]) -> Optional[Tuple]:
+        """Asynchronously handles a task based on a given task object and parameters."""
+        return await self.handle_fin_grind(task, data, **kwargs)
+
+
+class GiveRating(WithBriefing, LLMUsage):
+    """A class that provides functionality to rate tasks based on a rating manual and score range."""
+
+    async def rate_fine_grind(
+        self,
+        to_rate: str,
+        rating_manual: Dict[str, str],
+        score_range: Tuple[float, float],
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Dict[str, float]:
+        """Rates a given task based on a rating manual and score range.
+
+        Args:
+            to_rate: The task to be rated.
+            rating_manual: A dictionary containing the rating criteria.
+            score_range: A tuple representing the valid score range.
+            **kwargs: Additional keyword arguments for the LLM usage.
+
+        Returns:
+            A dictionary with the ratings for each dimension.
+        """
+
+        def _validator(response: str) -> Dict[str, float] | None:
+            if (
+                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
+                and isinstance(json_data, dict)
+                and json_data.keys() == rating_manual.keys()
+                and all(isinstance(v, float) for v in json_data.values())
+                and all(score_range[0] <= v <= score_range[1] for v in json_data.values())
+            ):
+                return json_data
+            return None
+
+        return await self.aask_validate(
+            question=(
+                template_manager.render_template(
+                    configs.templates.rate_fine_grind_template,
+                    {
+                        "to_rate": to_rate,
+                        "min_score": score_range[0],
+                        "max_score": score_range[1],
+                        "rating_manual": rating_manual,
+                    },
+                )
+            ),
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )
+
+    async def rate(
+        self,
+        to_rate: str,
+        topic: str,
+        dimensions: Set[str],
+        score_range: Tuple[float, float] = (0.0, 1.0),
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Dict[str, float]:
+        """Rates a task based on a topic and dimensions. this function will automatically draft a rating manual based on the topic and dimensions.
+
+        Args:
+            to_rate: The task to be rated.
+            topic: The topic related to the task.
+            dimensions: A set of dimensions for rating.
+            score_range: A tuple representing the valid score range
+            **kwargs: Additional keyword arguments for the LLM usage.
+
+        Returns:
+            A dictionary with the ratings for each dimension.
+        """
+        manual = await self.draft_rating_manual(topic, dimensions, **kwargs)
+        return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
+
+    async def draft_rating_manual(
+        self, topic: str, dimensions: Set[str], **kwargs: Unpack[ValidateKwargs]
+    ) -> Dict[str, str]:
+        """Drafts a rating manual based on a topic and dimensions.
+
+        Args:
+            topic: The topic for the rating manual.
+            dimensions: A set of dimensions for the rating manual.
+            **kwargs: Additional keyword arguments for the LLM usage.
+
+        Returns:
+            A dictionary representing the drafted rating manual.
+        """
+
+        def _validator(response: str) -> Dict[str, str] | None:
+            if (
+                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
+                and isinstance(json_data, dict)
+                and json_data.keys() == dimensions
+                and all(isinstance(v, str) for v in json_data.values())
+            ):
+                return json_data
+            return None
+
+        return await self.aask_validate(
+            question=(
+                template_manager.render_template(
+                    configs.templates.draft_rating_manual_template,
+                    {
+                        "topic": topic,
+                        "dimensions": dimensions,
+                    },
+                )
+            ),
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )
+
+    async def draft_rating_dimensions(
+        self,
+        topic: str,
+        dimensions_count: NonNegativeInt = 0,
+        examples: Optional[List[str]] = None,
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Set[str]:
+        """Drafts rating dimensions based on a topic.
+
+        Args:
+            topic: The topic for the rating dimensions.
+            dimensions_count: The number of dimensions to draft, 0 means no limit.
+            examples: A list of examples which is rated based on the rating dimensions.
+            **kwargs: Additional keyword arguments for the LLM usage.
+
+        Returns:
+            A set of rating dimensions.
+        """
+
+        def _validator(response: str) -> Set[str] | None:
+            if (
+                (json_data := JsonCapture.convert_with(response, orjson.loads)) is not None
+                and isinstance(json_data, list)
+                and all(isinstance(v, str) for v in json_data)
+                and (dimensions_count == 0 or len(json_data) == dimensions_count)
+            ):
+                return set(json_data)
+            return None
+
+        return await self.aask_validate(
+            question=(
+                template_manager.render_template(
+                    configs.templates.draft_rating_dimensions_template,
+                    {
+                        "topic": topic,
+                        "examples": examples,
+                        "dimensions_count": dimensions_count,
+                    },
+                )
+            ),
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/python/fabricatio/models/kwargs_types.py

@@ -18,9 +18,14 @@ class LLMKwargs(TypedDict):
     max_retries: NotRequired[PositiveInt]
 
 
-class ChooseKwargs(LLMKwargs):
-    """A type representing the keyword arguments for the choose method."""
+class ValidateKwargs(LLMKwargs):
+    """A type representing the keyword arguments for the validate method."""
 
     max_validations: NotRequired[PositiveInt]
+
+
+class ChooseKwargs(ValidateKwargs):
+    """A type representing the keyword arguments for the choose method."""
+
     system_message: NotRequired[str]
     k: NotRequired[NonNegativeInt]

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/python/fabricatio/models/role.py

@@ -5,14 +5,13 @@ from typing import Any, Self, Set
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.action import WorkFlow
-from fabricatio.models.advanced import ProposeTask
+from fabricatio.models.advanced import GiveRating, HandleTask, ProposeTask
 from fabricatio.models.events import Event
 from fabricatio.models.tool import ToolBox
-from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field
 
 
-class Role(ProposeTask, ToolBoxUsage):
+class Role(ProposeTask, HandleTask, GiveRating):
     """Class that represents a role with a registry of events and workflows."""
 
     registry: dict[Event | str, WorkFlow] = Field(...)

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/python/fabricatio/models/task.py

@@ -57,6 +57,9 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
     namespace: List[str] = Field(default_factory=list)
     """The namespace of the task, a list of namespace segment, as string."""
 
+    dependencies: List[str] = Field(default_factory=list)
+    """A list of file paths, These file are needed to read or write to meet a specific requirement of this task."""
+
     _output: Queue = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
     """The output queue of the task."""
 

fabricatio-0.2.1.dev3/templates/built-in/draft_rating_dimensions.hbs

@@ -0,0 +1,24 @@
+# Task
+Please draft rating dimensions for the topic: "{{ topic }}".
+Return the dimensions{{#if dimensions_count}} with length of {{ dimensions_count }}{{/if}} in JSON format as a list of strings within code block.
+
+
+# Example:
+returning dimensions{{#if dimensions_count}} with length of 3{{/if}} for the topic "Nice icecream"
+
+----- Start of response example -----
+```json
+[
+    "outlook",
+    "taste",
+    "texture"
+]
+```
+----- End of response example -----
+
+
+# Warning
+- Please ensure that the dimensions are clear and concise.
+- The response SHALL be returned as a JSON object within the codeblock.
+- No additional Explanation is needed.
+{{#if dimensions_count }}- You must return exactly {{ dimensions_count }} dimensions.{{/if}}

fabricatio-0.2.1.dev3/templates/built-in/draft_rating_manual.hbs

@@ -0,0 +1,26 @@
+# Task
+Please draft a rating manual for the following topic and dimensions, which will be used to rate the entity based.
+
+Topic: {{ topic }}
+Dimensions: {{ dimensions }}
+
+Return the rating manual as a JSON object within the codeblock where the keys are the dimensions and the values are the criteria for each dimension.
+
+
+# Example:
+
+topic: Nice icecream
+----- Start of response example -----
+```json
+{
+"outlook": "Appearance of the icecream, how it looks. High score for an ice cream with a beautiful appearance such as vibrant color combinations and topped with fresh fruits or chocolate pieces; low score for an ice cream that looks unappealing, possibly showing signs of melting or covered in ice crystals.",
+"taste": "How the icecream tastes. High score for delicious ice cream with rich and authentic flavors, like vanilla with natural vanilla bean aroma and moderate sweetness; low score for bland or overly sweet ice cream with noticeable artificial flavoring or not matching its claimed flavor.",
+"texture": "How the icecream feels. High score for smooth texture without icy bits, melts smoothly in the mouth providing a creamy experience; low score for rough texture containing many ice crystals, feeling like it has been frozen for too long lacking softness."
+}
+```
+----- end of response example -----
+
+# Warning
+- Please ensure that the rating manual is clear and concise, and that the criteria for each dimension are well-defined.
+- The response SHALL be returned as a JSON object within the codeblock.
+- No additional Explanation is needed.

fabricatio-0.2.1.dev3/templates/built-in/rate_fine_grind.hbs

@@ -0,0 +1,39 @@
+# Task:
+Please rate the following task based on the provided rating manual and score range.
+
+To rate text below:
+----- Start of text to tate -----
+{{ to_rate }}
+----- End of text to tate -----
+
+Rating Manual:
+{{ rating_manual }}
+
+Score Range:
+- Minimal score: {{ min_score }}
+- Maximum score is {{ max_score }}
+
+
+By referring the rating manual, rate the text based on the provided rating manual and score range.
+
+# Example:
+rate the cherry icecream with ["outlook", "taste", "texture"] dimensions, the score range is 0-5.
+
+----- Start of response example -----
+```json
+{
+  "outlook": 3.56,
+  "taste": 4.55,
+  "texture": 3.01
+}
+```
+----- end of response example -----
+
+
+# Warning
+- Please ensure that the rating is done based on the rating manual and score range provided.
+- The response SHALL be returned as a JSON object within the codeblock.
+- No additional Explanation is needed.
+- The rating for each dimension SHALL be rounded to two decimal places.
+- The score dor each dimension SHALL be within the score range provided, that is, not smaller than {{ min_score }} and not larger than {{ max_score }}.
+- the response SHALL include all the dimensions provided in the [{{#each rating_manual}}"{{@key}}",{{/each}}].

{fabricatio-0.2.1.dev1 → fabricatio-0.2.1.dev3}/uv.lock

@@ -216,7 +216,7 @@ wheels = [
 
 [[package]]
 name = "fabricatio"
-version = "0.2.1.dev1"
+version = "0.2.1.dev3"
 source = { editable = "." }
 dependencies = [
     { name = "appdirs" },

fabricatio-0.2.1.dev1/python/fabricatio/models/advanced.py

@@ -1,128 +0,0 @@
-"""A module for advanced models and functionalities."""
-
-from types import CodeType
-from typing import Any, Dict, 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(WithBriefing, LLMUsage):
-    """A class that proposes a task based on a prompt."""
-
-    async def propose[T](
-        self,
-        prompt: str,
-        max_validations: PositiveInt = 2,
-        **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.
-            **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(configs.templates.propose_task_template, 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],
-        data: Dict[str, Any],
-        **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
-
-        q = template_manager.render_template(
-            configs.templates.draft_tool_usage_code_template,
-            {
-                "data_module_name": configs.toolbox.data_module_name,
-                "tool_module_name": configs.toolbox.tool_module_name,
-                "task": task.briefing,
-                "deps": task.dependencies_prompt,
-                "tools": [{"name": t.name, "briefing": t.briefing} for t in tools],
-                "data": data,
-            },
-        )
-        logger.debug(f"Code Drafting Question: \n{q}")
-        return await self.aask_validate(
-            question=q,
-            validator=_validator,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-            **kwargs,
-        )
-
-    async def handle_fin_grind(
-        self,
-        task: Task,
-        data: Dict[str, Any],
-        **kwargs: Unpack[LLMKwargs],
-    ) -> Optional[Tuple]:
-        """Asynchronously handles a task based on a given task object and parameters."""
-        logger.info(f"Handling task: \n{task.briefing}")
-
-        tools = await self.gather_tools(task)
-        logger.info(f"{self.name} have gathered {[t.name for t in tools]}")
-
-        if tools:
-            executor = ToolExecutor(candidates=tools, data=data)
-            code, to_extract = await self.draft_tool_usage_code(task, tools, data, **kwargs)
-
-            cxt = executor.execute(code)
-            if to_extract:
-                return tuple(cxt.get(k) for k in to_extract)
-
-        return None