fabricatio 0.2.1.dev3__tar.gz → 0.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.1.dev3
+Version: 0.2.2
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -15,6 +15,7 @@ Requires-Dist: gitpython>=3.1.44
 Requires-Dist: litellm>=1.60.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: magika>=0.5.1
+Requires-Dist: more-itertools>=10.6.0
 Requires-Dist: orjson>=3.10.15
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: pydantic-settings>=2.7.1
@@ -22,7 +23,6 @@ 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

{fabricatio-0.2.1.dev3 → fabricatio-0.2.2}/examples/make_a_rating/rating.py

@@ -15,17 +15,13 @@ class Rate(Action):
     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]]:
+    async def _execute(self, to_rate: List[str], rate_topic: str, criteria: Set[str], **_) -> List[Dict[str, float]]:
+        logger.info(f"Rating the: \n{to_rate}")
         """Rate the task."""
-        return await asyncio.gather(
-            *[
-                self.rate(
-                    target,
-                    rate_topic,
-                    dimensions,
-                )
-                for target in to_rate
-            ]
+        return await self.rate(
+            to_rate,
+            rate_topic,
+            criteria,
         )
 
 
@@ -56,6 +52,32 @@ class WhatToRate(Action):
         )
 
 
+class MakeCriteria(Action):
+    """Make criteria for rating."""
+
+    name: str = "make criteria"
+    output_key: str = "criteria"
+
+    async def _execute(self, rate_topic: str, to_rate: List[str], **cxt: Unpack) -> Set[str]:
+        criteria = await self.draft_rating_criteria_from_examples(rate_topic, to_rate)
+        logger.info(f"Criteria: \n{criteria}")
+        return set(criteria)
+
+
+class MakeCompositeScore(Action):
+    """Make a composite score."""
+
+    name: str = "make composite score"
+
+    output_key: str = "task_output"
+
+    async def _execute(self, rate_topic: str, to_rate: List[str], **cxt: Unpack) -> List[float]:
+        return await self.composite_score(
+            rate_topic,
+            to_rate,
+        )
+
+
 async def main() -> None:
     """Main function."""
     role = Role(
@@ -67,18 +89,40 @@ async def main() -> None:
                 steps=(WhatToRate, Rate),
                 extra_init_context={
                     "rate_topic": "If this food is cheap and delicious",
-                    "dimensions": {"taste", "price", "quality", "safety", "healthiness", "freshness"},
+                    "criteria": {"taste", "price", "quality", "safety", "healthiness"},
+                },
+            ),
+            Event.instantiate_from("make_criteria_for_food").push_wildcard().push("pending"): WorkFlow(
+                name="Make criteria for food",
+                steps=(WhatToRate, MakeCriteria, Rate),
+                extra_init_context={
+                    "rate_topic": "if the food is 'good'",
+                },
+            ),
+            Event.instantiate_from("make_composite_score").push_wildcard().push("pending"): WorkFlow(
+                name="Make composite score",
+                steps=(WhatToRate, MakeCompositeScore),
+                extra_init_context={
+                    "rate_topic": "if the food is 'good'",
                 },
             ),
         },
     )
     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",
+        "rate these food, so that i can decide what to eat today. choco cake, strawberry icecream, giga burger, cup of coffee, rotten bread from the trash bin, and a salty of fruit salad",
     )
     rating = await task.move_to("rate_food").delegate()
 
     logger.success(f"Result: \n{rating}")
 
+    generated_criteria = await task.move_to("make_criteria_for_food").delegate()
+
+    logger.success(f"Generated Criteria: \n{generated_criteria}")
+
+    composite_score = await task.move_to("make_composite_score").delegate()
+
+    logger.success(f"Composite Score: \n{composite_score}")
+
 
 if __name__ == "__main__":
     asyncio.run(main())

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

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.1-dev3"
+version = "0.2.2"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -34,6 +34,7 @@ dependencies = [
     "litellm>=1.60.0",
     "loguru>=0.7.3",
     "magika>=0.5.1",
+    "more-itertools>=10.6.0",
     "orjson>=3.10.15",
     "pydantic>=2.10.6",
     "pydantic-settings>=2.7.1",
@@ -76,7 +77,6 @@ dev = [
 
 [project.optional-dependencies]
 rag = [
-    "faiss-cpu>=1.10.0",
     "pymilvus>=2.5.4",
 ]
 

fabricatio-0.2.2/python/fabricatio/capabilities/rating.py

@@ -0,0 +1,355 @@
+"""A module that provides functionality to rate tasks based on a rating manual and score range."""
+
+from asyncio import gather
+from itertools import permutations
+from typing import Dict, List, Set, Tuple, Union, Unpack, overload
+
+import orjson
+from fabricatio._rust_instances import template_manager
+from fabricatio.config import configs
+from fabricatio.journal import logger
+from fabricatio.models.generic import WithBriefing
+from fabricatio.models.kwargs_types import GenerateKwargs, ValidateKwargs
+from fabricatio.models.usages import LLMUsage
+from fabricatio.parser import JsonCapture
+from more_itertools import flatten, windowed
+from pydantic import NonNegativeInt, PositiveInt
+
+
+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]:
+        """Rate a given string based on a rating manual and score range.
+
+        Args:
+            to_rate (str): The string to be rated.
+            rating_manual (Dict[str, str]): A dictionary containing the rating criteria.
+            score_range (Tuple[float, float]): A tuple representing the valid score range.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            Dict[str, float]: 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
+
+        logger.info(f"Rating for {to_rate}")
+        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,
+        )
+
+    @overload
+    async def rate(
+        self,
+        to_rate: str,
+        topic: str,
+        criteria: Set[str],
+        score_range: Tuple[float, float] = (0.0, 1.0),
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Dict[str, float]: ...
+
+    @overload
+    async def rate(
+        self,
+        to_rate: List[str],
+        topic: str,
+        criteria: Set[str],
+        score_range: Tuple[float, float] = (0.0, 1.0),
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> List[Dict[str, float]]: ...
+
+    async def rate(
+        self,
+        to_rate: Union[str, List[str]],
+        topic: str,
+        criteria: Set[str],
+        score_range: Tuple[float, float] = (0.0, 1.0),
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Union[Dict[str, float], List[Dict[str, float]]]:
+        """Rate a given string or a sequence of strings based on a topic, criteria, and score range.
+
+        Args:
+            to_rate (Union[str, List[str]]): The string or sequence of strings to be rated.
+            topic (str): The topic related to the task.
+            criteria (Set[str]): A set of criteria for rating.
+            score_range (Tuple[float, float], optional): A tuple representing the valid score range. Defaults to (0.0, 1.0).
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            Union[Dict[str, float], List[Dict[str, float]]]: A dictionary with the ratings for each criterion if a single string is provided,
+            or a list of dictionaries with the ratings for each criterion if a sequence of strings is provided.
+        """
+        manual = await self.draft_rating_manual(topic, criteria, **kwargs)
+        if isinstance(to_rate, str):
+            return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
+        if isinstance(to_rate, list):
+            return await gather(*[self.rate_fine_grind(item, manual, score_range, **kwargs) for item in to_rate])
+        raise ValueError("to_rate must be a string or a list of strings")
+
+    async def draft_rating_manual(
+        self, topic: str, criteria: Set[str], **kwargs: Unpack[ValidateKwargs]
+    ) -> Dict[str, str]:
+        """Drafts a rating manual based on a topic and dimensions.
+
+        Args:
+            topic (str): The topic for the rating manual.
+            criteria (Set[str]): A set of dimensions for the rating manual.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            Dict[str, str]: 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() == criteria
+                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,
+                        "criteria": criteria,
+                    },
+                )
+            ),
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )
+
+    async def draft_rating_criteria(
+        self,
+        topic: str,
+        criteria_count: NonNegativeInt = 0,
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Set[str]:
+        """Drafts rating dimensions based on a topic.
+
+        Args:
+            topic (str): The topic for the rating dimensions.
+            criteria_count (NonNegativeInt, optional): The number of dimensions to draft, 0 means no limit. Defaults to 0.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            Set[str]: 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 (criteria_count == 0 or len(json_data) == criteria_count)
+            ):
+                return set(json_data)
+            return None
+
+        return await self.aask_validate(
+            question=(
+                template_manager.render_template(
+                    configs.templates.draft_rating_criteria_template,
+                    {
+                        "topic": topic,
+                        "criteria_count": criteria_count,
+                    },
+                )
+            ),
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )
+
+    async def draft_rating_criteria_from_examples(
+        self,
+        topic: str,
+        examples: List[str],
+        reasons_count: PositiveInt = 2,
+        criteria_count: PositiveInt = 5,
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Set[str]:
+        """Asynchronously drafts a set of rating criteria based on provided examples.
+
+        This function generates rating criteria by analyzing examples and extracting reasons for comparison,
+        then further condensing these reasons into a specified number of criteria.
+
+        Parameters:
+            topic (str): The subject topic for the rating criteria.
+            examples (List[str]): A list of example texts to analyze.
+            reasons_count (PositiveInt, optional): The number of reasons to extract from each pair of examples. Defaults to 2.
+            criteria_count (PositiveInt, optional): The final number of rating criteria to draft. Defaults to 5.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for validation.
+
+        Returns:
+            Set[str]: A set of drafted rating criteria.
+        """
+
+        def _reasons_validator(response: str) -> List[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 len(json_data) == reasons_count
+            ):
+                return json_data
+            return None
+
+        def _criteria_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 len(json_data) == criteria_count
+            ):
+                return set(json_data)
+            return None
+
+        kwargs = GenerateKwargs(system_message=f"# your personal briefing: \n{self.briefing}", **kwargs)
+        # extract reasons from the comparison of ordered pairs of extracted from examples
+        reasons = flatten(
+            await self.aask_validate_batch(
+                questions=[
+                    template_manager.render_template(
+                        configs.templates.extract_reasons_from_examples_template,
+                        {
+                            "topic": topic,
+                            "first": pair[0],
+                            "second": pair[1],
+                            "reasons_count": reasons_count,
+                        },
+                    )
+                    for pair in (permutations(examples, 2))
+                ],
+                validator=_reasons_validator,
+                **kwargs,
+            )
+        )
+        # extract certain mount of criteria from reasons according to their importance and frequency
+        return await self.aask_validate(
+            question=(
+                template_manager.render_template(
+                    configs.templates.extract_criteria_from_reasons_template,
+                    {
+                        "topic": topic,
+                        "reasons": list(reasons),
+                        "criteria_count": criteria_count,
+                    },
+                )
+            ),
+            validator=_criteria_validator,
+            **kwargs,
+        )
+
+    async def drafting_rating_weights_klee(
+        self,
+        topic: str,
+        criteria: Set[str],
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> Dict[str, float]:
+        """Drafts rating weights for a given topic and criteria using the Klee method.
+
+        Args:
+            topic (str): The topic for the rating weights.
+            criteria (Set[str]): A set of criteria for the rating weights.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            Dict[str, float]: A dictionary representing the drafted rating weights for each criterion.
+        """
+        if len(criteria) < 2:  # noqa: PLR2004
+            raise ValueError("At least two criteria are required to draft rating weights")
+
+        def _validator(resp: str) -> float | None:
+            if (cap := JsonCapture.convert_with(resp, orjson.loads)) is not None and isinstance(cap, float):
+                return cap
+            return None
+
+        criteria = list(criteria)  # freeze the order
+        windows = windowed(criteria, 2)
+
+        # get the importance multiplier indicating how important is second criterion compared to the first one
+        relative_weights = await self.aask_validate_batch(
+            questions=[
+                template_manager.render_template(
+                    configs.templates.draft_rating_weights_klee_template,
+                    {
+                        "topic": topic,
+                        "first": pair[0],
+                        "second": pair[1],
+                    },
+                )
+                for pair in windows
+            ],
+            validator=_validator,
+            **GenerateKwargs(system_message=f"# your personal briefing: \n{self.briefing}", **kwargs),
+        )
+        weights = [1]
+        for rw in relative_weights:
+            weights.append(weights[-1] * rw)
+        total = sum(weights)
+        return dict(zip(criteria, [w / total for w in weights], strict=True))
+
+    async def composite_score(
+        self,
+        topic: str,
+        to_rate: List[str],
+        reasons_count: PositiveInt = 2,
+        criteria_count: PositiveInt = 5,
+        **kwargs: Unpack[ValidateKwargs],
+    ) -> List[float]:
+        """Calculates the composite scores for a list of items based on a given topic and criteria.
+
+        Args:
+            topic (str): The topic for the rating.
+            to_rate (List[str]): A list of strings to be rated.
+            reasons_count (PositiveInt, optional): The number of reasons to extract from each pair of examples. Defaults to 2.
+            criteria_count (PositiveInt, optional): The number of criteria to draft. Defaults to 5.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            List[float]: A list of composite scores for the items.
+        """
+        criteria = await self.draft_rating_criteria_from_examples(
+            topic, to_rate, reasons_count, criteria_count, **kwargs
+        )
+        weights = await self.drafting_rating_weights_klee(topic, criteria, **kwargs)
+        logger.info(f"Criteria: {criteria}\nWeights: {weights}")
+        ratings_seq = await self.rate(to_rate, topic, criteria, **kwargs)
+
+        return [sum(ratings[c] * weights[c] for c in criteria) for ratings in ratings_seq]

fabricatio-0.2.2/python/fabricatio/capabilities/task.py

@@ -0,0 +1,131 @@
+"""A module for the task capabilities of the Fabricatio library."""
+
+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 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 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)

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

@@ -163,8 +163,17 @@ class TemplateConfig(BaseModel):
     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."""
+    draft_rating_criteria_template: str = Field(default="draft_rating_criteria")
+    """The name of the draft rating criteria template which will be used to draft rating criteria."""
+
+    extract_reasons_from_examples_template: str = Field(default="extract_reasons_from_examples")
+    """The name of the extract reasons from examples template which will be used to extract reasons from examples."""
+
+    extract_criteria_from_reasons_template: str = Field(default="extract_criteria_from_reasons")
+    """The name of the extract criteria from reasons template which will be used to extract criteria from reasons."""
+
+    draft_rating_weights_klee_template: str = Field(default="draft_rating_weights_klee")
+    """The name of the draft rating weights klee template which will be used to draft rating weights with Klee method."""
 
 
 class MagikaConfig(BaseModel):

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

@@ -5,8 +5,9 @@ from abc import abstractmethod
 from asyncio import Queue
 from typing import Any, Dict, Self, Tuple, Type, Union, Unpack
 
+from fabricatio.capabilities.rating import GiveRating
+from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.journal import logger
-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

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

@@ -24,8 +24,13 @@ class ValidateKwargs(LLMKwargs):
     max_validations: NotRequired[PositiveInt]
 
 
-class ChooseKwargs(ValidateKwargs):
-    """A type representing the keyword arguments for the choose method."""
+class GenerateKwargs(ValidateKwargs):
+    """A type representing the keyword arguments for the generate method."""
 
     system_message: NotRequired[str]
+
+
+class ChooseKwargs(GenerateKwargs):
+    """A type representing the keyword arguments for the choose method."""
+
     k: NotRequired[NonNegativeInt]