fabricatio 0.2.1.dev3__cp312-cp312-win_amd64.whl → 0.2.2__cp312-cp312-win_amd64.whl

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/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/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/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/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]

fabricatio/models/role.py

@@ -2,10 +2,11 @@
 
 from typing import Any, Self, Set
 
+from fabricatio.capabilities.rating import GiveRating
+from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.action import WorkFlow
-from fabricatio.models.advanced import GiveRating, HandleTask, ProposeTask
 from fabricatio.models.events import Event
 from fabricatio.models.tool import ToolBox
 from pydantic import Field

fabricatio/models/task.py

@@ -46,19 +46,19 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
     """
 
     name: str = Field(...)
-    """The name of the task."""
+    """The name of the task, which should be a concise and descriptive name."""
 
     description: str = Field(default="")
-    """The description of the task."""
+    """The description of the task, which should provide every details and noting about the task if provided, obeying the CEFR level rule and 5W1H rule."""
 
     goal: List[str] = Field(default=[])
-    """The goal of the task, a list of strings."""
+    """The goal of the task, a list of strings. The goal should be a concise and clear statement of what the task is intended to achieve, goal SHALL NOT be too broad or too narrow."""
 
     namespace: List[str] = Field(default_factory=list)
-    """The namespace of the task, a list of namespace segment, as string."""
+    """The namespace of the task, a list of namespace segment, as string, if it is not directly given out, it SHALL just be a empty list meaning `NOT ASSIGNED`"""
 
     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."""
+    """A list of file paths, These file are needed to read or write to meet a specific requirement of this task, if it is not directly given out, it SHALL just be a empty list meaning `NOT ASSIGNED`"""
 
     _output: Queue = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
     """The output queue of the task."""

fabricatio/models/usages.py

@@ -10,7 +10,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.kwargs_types import ChooseKwargs, GenerateKwargs, LLMKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
 from fabricatio.models.utils import Messages
@@ -72,10 +72,10 @@ class LLMUsage(Base):
         Args:
             messages (List[Dict[str, str]]): A list of messages, where each message is a dictionary containing the role and content of the message.
             n (PositiveInt | None): The number of responses to generate. Defaults to the instance's `llm_generation_count` or the global configuration.
-            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            ModelResponse: An object containing the generated response and other metadata from the model.
+            ModelResponse | CustomStreamWrapper: An object containing the generated response and other metadata from the model.
         """
         # Call the underlying asynchronous completion function with the provided and default parameters
         return await litellm.acompletion(
@@ -108,7 +108,7 @@ class LLMUsage(Base):
             question (str): The question to ask the model.
             system_message (str): The system message to provide context to the model. Defaults to an empty string.
             n (PositiveInt | None): The number of responses to generate. Defaults to the instance's `llm_generation_count` or the global configuration.
-            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             List[Choices | StreamingChoices]: A list of choices or streaming choices from the model response.
@@ -170,12 +170,12 @@ class LLMUsage(Base):
         """Asynchronously asks the language model a question and returns the response content.
 
         Args:
-            question (str): The question to ask the model.
-            system_message (str): The system message to provide context to the model. Defaults to an empty string.
-            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+            question (str | List[str]): The question to ask the model.
+            system_message (str | List[str] | None): The system message to provide context to the model. Defaults to an empty string.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            str: The content of the model's response message.
+            str | List[str]: The content of the model's response message.
         """
         system_message = system_message or ""
         match (isinstance(question, list), isinstance(system_message, list)):
@@ -226,7 +226,7 @@ class LLMUsage(Base):
             validator (Callable[[str], T | None]): A function to validate the response.
             max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 2.
             system_message (str): System message to include in the request. Defaults to an empty string.
-            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             T: The validated response.
@@ -248,14 +248,33 @@ class LLMUsage(Base):
         logger.error(f"Failed to validate the response after {max_validations} attempts.")
         raise ValueError("Failed to validate the response.")
 
+    async def aask_validate_batch[T](
+        self,
+        questions: List[str],
+        validator: Callable[[str], T | None],
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> List[T]:
+        """Asynchronously asks a batch of questions and validates the responses using a given validator.
+
+        Args:
+            questions (List[str]): The list of questions to ask.
+            validator (Callable[[str], T | None]): A function to validate the response.
+            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
+
+        Returns:
+            T: The validated response.
+
+        Raises:
+            ValueError: If the response fails to validate after the maximum number of attempts.
+        """
+        return await gather(*[self.aask_validate(question, validator, **kwargs) for question in questions])
+
     async def achoose[T: WithBriefing](
         self,
         instruction: str,
         choices: List[T],
         k: NonNegativeInt = 0,
-        max_validations: PositiveInt = 2,
-        system_message: str = "",
-        **kwargs: Unpack[LLMKwargs],
+        **kwargs: Unpack[GenerateKwargs],
     ) -> List[T]:
         """Asynchronously executes a multi-choice decision-making process, generating a prompt based on the instruction and options, and validates the returned selection results.
 
@@ -263,9 +282,7 @@ class LLMUsage(Base):
             instruction (str): The user-provided instruction/question description.
             choices (List[T]): A list of candidate options, requiring elements to have `name` and `briefing` fields.
             k (NonNegativeInt): The number of choices to select, 0 means infinite. Defaults to 0.
-            max_validations (PositiveInt): Maximum number of validation failures, default is 2.
-            system_message (str): Custom system-level prompt, defaults to an empty string.
-            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             List[T]: The final validated selection result list, with element types matching the input `choices`.
@@ -301,8 +318,6 @@ class LLMUsage(Base):
         return await self.aask_validate(
             question=prompt,
             validator=_validate,
-            max_validations=max_validations,
-            system_message=system_message,
             **kwargs,
         )
 
@@ -310,21 +325,14 @@ class LLMUsage(Base):
         self,
         instruction: str,
         choices: List[T],
-        max_validations: PositiveInt = 2,
-        system_message: str = "",
-        **kwargs: Unpack[LLMKwargs],
+        **kwargs: Unpack[GenerateKwargs],
     ) -> T:
         """Asynchronously picks a single choice from a list of options using AI validation.
 
-        This method is a convenience wrapper around `achoose` that always selects exactly one item.
-
         Args:
             instruction (str): The user-provided instruction/question description.
             choices (List[T]): A list of candidate options, requiring elements to have `name` and `briefing` fields.
-            max_validations (PositiveInt): Maximum number of validation failures, default is 2.
-            system_message (str): Custom system-level prompt, defaults to an empty string.
-            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`,
-                `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             T: The single selected item from the choices list.
@@ -337,8 +345,6 @@ class LLMUsage(Base):
                 instruction=instruction,
                 choices=choices,
                 k=1,
-                max_validations=max_validations,
-                system_message=system_message,
                 **kwargs,
             )
         )[0]
@@ -348,9 +354,7 @@ class LLMUsage(Base):
         prompt: str,
         affirm_case: str = "",
         deny_case: str = "",
-        max_validations: PositiveInt = 2,
-        system_message: str = "",
-        **kwargs: Unpack[LLMKwargs],
+        **kwargs: Unpack[GenerateKwargs],
     ) -> bool:
         """Asynchronously judges a prompt using AI validation.
 
@@ -358,16 +362,10 @@ class LLMUsage(Base):
             prompt (str): The input prompt to be judged.
             affirm_case (str): The affirmative case for the AI model. Defaults to an empty string.
             deny_case (str): The negative case for the AI model. Defaults to an empty string.
-            max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 2.
-            system_message (str): System message for the AI model. Defaults to an empty string.
-            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
 
         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:
@@ -382,8 +380,6 @@ class LLMUsage(Base):
                 {"prompt": prompt, "affirm_case": affirm_case, "deny_case": deny_case},
             ),
             validator=_validate,
-            max_validations=max_validations,
-            system_message=system_message,
             **kwargs,
         )
 
@@ -448,7 +444,7 @@ class ToolBoxUsage(LLMUsage):
             system_message (str): Custom system-level prompt, defaults to an empty string.
             k (NonNegativeInt): The number of toolboxes to select, 0 means infinite. Defaults to 0.
             max_validations (PositiveInt): Maximum number of validation failures, default is 2.
-            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             List[ToolBox]: The selected toolboxes.
@@ -482,7 +478,7 @@ class ToolBoxUsage(LLMUsage):
             system_message (str): Custom system-level prompt, defaults to an empty string.
             k (NonNegativeInt): The number of tools to select, 0 means infinite. Defaults to 0.
             max_validations (PositiveInt): Maximum number of validation failures, default is 2.
-            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             List[Tool]: The selected tools.
@@ -509,8 +505,8 @@ class ToolBoxUsage(LLMUsage):
 
         Args:
             task (Task): The task for which to gather tools.
-            box_choose_kwargs (Optional[ChooseKwargs]): Keyword arguments for choosing toolboxes, such as `system_message`, `k`, `max_validations`, `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
-            tool_choose_kwargs (Optional[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`.
+            box_choose_kwargs (Optional[ChooseKwargs]): Keyword arguments for choosing toolboxes.
+            tool_choose_kwargs (Optional[ChooseKwargs]): Keyword arguments for choosing tools.
 
         Returns:
             List[Tool]: A list of tools gathered based on the provided task and toolbox and tool selection criteria.
@@ -531,7 +527,7 @@ class ToolBoxUsage(LLMUsage):
 
         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`.
+            **kwargs (Unpack[ChooseKwargs]): Keyword arguments for choosing tools.
 
         Returns:
             List[Tool]: A list of tools gathered based on the provided task.

{fabricatio-0.2.1.dev3.dist-info → fabricatio-0.2.2.dist-info}/METADATA

@@ -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.dist-info → fabricatio-0.2.2.dist-info}/RECORD

@@ -1,25 +1,26 @@
-fabricatio-0.2.1.dev3.dist-info/METADATA,sha256=OwlHmlzaQ2C89QQVzGZUKNkNHKb6rAjeAFRShKYSfkM,12351
-fabricatio-0.2.1.dev3.dist-info/WHEEL,sha256=tpW5AN9B-9qsM9WW2FXG2r193YXiqexDadpKp0A2daI,96
-fabricatio-0.2.1.dev3.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio-0.2.2.dist-info/METADATA,sha256=Xnkw59IiSN4arPkzglC1JKpJACZlGkjbr5raJLdrmb8,12334
+fabricatio-0.2.2.dist-info/WHEEL,sha256=tpW5AN9B-9qsM9WW2FXG2r193YXiqexDadpKp0A2daI,96
+fabricatio-0.2.2.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
 fabricatio/actions/communication.py,sha256=NZxIIncKgJSDyBrqNebUtH_haqtxHa8ld2TZxT3CMdU,429
 fabricatio/actions/transmission.py,sha256=xpvKqbXqgpi1BWy-vUUvmd8NZ1GhRNfsYUBp-l2jLyk,862
 fabricatio/actions/__init__.py,sha256=eFmFVPQvtNgFynIXBVr3eP-vWQDWCPng60YY5LXvZgg,115
-fabricatio/config.py,sha256=qHPChDvzoclDLuaykHr8qlJq1zE3RjU6jObSNe11C1Y,10822
+fabricatio/capabilities/rating.py,sha256=zmTUvsUfxFgovRQzy4djL2zKRYTHmN6JY7A4lyT5uVQ,14907
+fabricatio/capabilities/task.py,sha256=d2xtrwQxXWI40UskQCR5YhHarY7ST0ppr8TjY12uWQE,5327
+fabricatio/config.py,sha256=wzaaUHZZMRCYc37M_M4qKuLOYtwdEjYtyG77-AGkqCg,11467
 fabricatio/core.py,sha256=yQK2ZrbPYDJOaNDp0Bky3muTkB-ZaQ1ld_Qfflm2dY0,5938
 fabricatio/decorators.py,sha256=uzsP4tFKQNjDHBkofsjjoJA0IUAaYOtt6YVedoyOqlo,6551
 fabricatio/fs/curd.py,sha256=faMstgGUiQ4k2AW3OXfvvWWTldTtKXco7QINYaMjmyA,3981
 fabricatio/fs/readers.py,sha256=Pz1-cdZYtmqr032dsroImlkFXAd0kCYY_9qVpD4UrG4,1045
 fabricatio/fs/__init__.py,sha256=lWcKYg0v3mv2LnnSegOQaTtlVDODU0vtw_s6iKU5IqQ,122
 fabricatio/journal.py,sha256=siqimKF0M_QaaOCMxtjr_BJVNyUIAQWILzE9Q4T6-7c,781
-fabricatio/models/action.py,sha256=VenovcZyR_ibwEy5Jpr4EaNP1L0hRqAjW0IhQNLdpNE,5676
-fabricatio/models/advanced.py,sha256=xVzHqoO1glNdCqflKZF5FGkK5GQmfIMZpT_07zQi9KM,11420
+fabricatio/models/action.py,sha256=Urs16f99CzRRAwulslgikloOAb_Ln9ZYKunKJpsAzu0,5721
 fabricatio/models/events.py,sha256=mrihNEFgQ5o7qFWja1z_qX8dnaTLwPBoJdVlzxQV5oM,2719
 fabricatio/models/generic.py,sha256=WEjZ96rTyBjaBjkM6e8E4Pg_Naot4xWRvGJteqBiCCI,5133
-fabricatio/models/kwargs_types.py,sha256=sVEkaeujQDNnQzTlisnjjVjrqS2g_wa4ROVbD86nHCE,1024
-fabricatio/models/role.py,sha256=h_0NIKvPbmRam4jsZOCGOMaje4gy5jYjTMpM39oTaYI,1785
-fabricatio/models/task.py,sha256=It4pUoaNIIC4Jw66KOG07Vp0bumCJZQo61KnR7HoGzM,9435
+fabricatio/models/kwargs_types.py,sha256=nTtD3wzSpCg-NlrJ43yW6lmfeWzD2V_XGMPlL5mXzyc,1147
+fabricatio/models/role.py,sha256=gYvleTeKUGDUNKPAC5B0EPMLC4jZ4vHsFHmHiVXkU6c,1830
+fabricatio/models/task.py,sha256=CBZL016mchj7X9Tnd-pqBxJ4mgFYq0tJ8Rq_22zZz4A,9905
 fabricatio/models/tool.py,sha256=WTFnpF6xZ1nJbmIOonLsGQcM-kkDCeZiAFqyil9xg2U,6988
-fabricatio/models/usages.py,sha256=6qoh9w1xeC-olkQjiH1oZYgqxohp0GX4dwOmSrhMn0E,25756
+fabricatio/models/usages.py,sha256=iLxas1gE7MA55ZtQJJ-qu3W6JP5KLjPgmNKqNYIF6yU,23972
 fabricatio/models/utils.py,sha256=i_kpcQpct04mQFk1nbcVGV-pl1YThWu4Qk3wbewzKkc,2535
 fabricatio/parser.py,sha256=uLabsvF07wRKW1PoTGuGEENCx3P4mhmuO8JkmOEkKko,3522
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,6 +31,6 @@ fabricatio/toolboxes/__init__.py,sha256=b13KmASO8q5fBLwew964fn9oH86ER5g-S1PgA4fZ
 fabricatio/_rust.pyi,sha256=0wCqtwWkVxxoqprvk8T27T8QYKIAKHS7xgsmdMNjQKc,1756
 fabricatio/_rust_instances.py,sha256=dl0-yZ4UvT5g20tQgnPJpmqtkjFGXNG_YK4eLfi_ugQ,279
 fabricatio/__init__.py,sha256=opIrN8lGyT-h2If4Qez0bRuWBa3uIT9GsM9CZy7_XJ0,1100
-fabricatio/_rust.cp312-win_amd64.pyd,sha256=p9QIx4phvmlr_ae1700OGjD1tVJRvkRCe9mWy_T4Z4U,1261056
-fabricatio-0.2.1.dev3.data/scripts/tdown.exe,sha256=-jC9BrzFlXOyBsw3O3T4XTMqirtLGPXPtOE1gE4uh3M,3397120
-fabricatio-0.2.1.dev3.dist-info/RECORD,,
+fabricatio/_rust.cp312-win_amd64.pyd,sha256=4hsd6r-pYsSUSW2cSq9Ik-SSTYVXacEYygliOFx2sfk,1262080
+fabricatio-0.2.2.data/scripts/tdown.exe,sha256=T_R2-mppH1q8T8LtZdR_pa7QNrdVfrC2nRQuWgalpqQ,3396608
+fabricatio-0.2.2.dist-info/RECORD,,

fabricatio/models/advanced.py

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