fabricatio 0.2.7.dev4__cp312-cp312-win_amd64.whl → 0.2.8__cp312-cp312-win_amd64.whl

fabricatio/capabilities/review.py

@@ -1,181 +1,19 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
-from typing import Dict, List, Optional, Self, Set, Unpack, cast
+from typing import Dict, Optional, Set, Unpack
 
-from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
-from fabricatio.capabilities.rating import GiveRating
+from fabricatio.capabilities.rating import Rating
 from fabricatio.config import configs
-from fabricatio.models.generic import Base, Display, ProposedAble, WithBriefing
+from fabricatio.models.extra.problem import Improvement
+from fabricatio.models.generic import Display, WithBriefing
 from fabricatio.models.kwargs_types import ReviewKwargs, ValidateKwargs
 from fabricatio.models.task import Task
-from fabricatio.models.utils import ask_edit
-from questionary import Choice, checkbox, text
-from questionary import print as q_print
-from rich import print as r_print
+from fabricatio.rust_instances import TEMPLATE_MANAGER
+from fabricatio.utils import ok
 
 
-class ProblemSolutions(Base):
-    """Represents a problem-solution pair identified during a review process.
-
-    This class encapsulates a single problem with its corresponding potential solutions,
-    providing a structured way to manage review findings.
-
-    Attributes:
-        problem (str): The problem statement identified during review.
-        solutions (List[str]): A collection of potential solutions to address the problem.
-    """
-
-    problem: str
-    """The problem identified in the review."""
-    solutions: List[str]
-    """A collection of potential solutions to address the problem."""
-
-    def update_problem(self, problem: str) -> Self:
-        """Update the problem description.
-
-        Args:
-            problem (str): The new problem description to replace the current one.
-
-        Returns:
-            Self: The current instance with updated problem description.
-        """
-        self.problem = problem
-        return self
-
-    def update_solutions(self, solutions: List[str]) -> Self:
-        """Update the list of potential solutions.
-
-        Args:
-            solutions (List[str]): The new collection of solutions to replace the current ones.
-
-        Returns:
-            Self: The current instance with updated solutions.
-        """
-        self.solutions = solutions
-        return self
-
-    async def edit_problem(self) -> Self:
-        """Interactively edit the problem description using a prompt.
-
-        Returns:
-            Self: The current instance with updated problem description.
-        """
-        self.problem = await text("Please edit the problem below:", default=self.problem).ask_async()
-        return self
-
-    async def edit_solutions(self) -> Self:
-        """Interactively edit the list of potential solutions using a prompt.
-
-        Returns:
-            Self: The current instance with updated solutions.
-        """
-        q_print(self.problem, style="bold cyan")
-        self.solutions = await ask_edit(self.solutions)
-        return self
-
-
-class ReviewResult[T](ProposedAble, Display):
-    """Represents the outcome of a review process with identified problems and solutions.
-
-    This class maintains a structured collection of problems found during a review,
-    their proposed solutions, and a reference to the original reviewed object.
-
-    Attributes:
-        review_topic (str): The subject or focus area of the review.
-        problem_solutions (List[ProblemSolutions]): Collection of problems identified
-            during review along with their potential solutions.
-
-    Type Parameters:
-        T: The type of the object being reviewed.
-    """
-
-    review_topic: str
-    """The subject or focus area of the review."""
-
-    problem_solutions: List[ProblemSolutions]
-    """Collection of problems identified during review along with their potential solutions."""
-
-    _ref: T
-    """Reference to the original object that was reviewed."""
-
-    def update_topic(self, topic: str) -> Self:
-        """Update the review topic.
-
-        Args:
-            topic (str): The new topic to be associated with this review.
-
-        Returns:
-            Self: The current instance with updated review topic.
-        """
-        self.review_topic = topic
-        return self
-
-    def update_ref[K](self, ref: K) -> "ReviewResult[K]":
-        """Update the reference to the reviewed object.
-
-        Args:
-            ref (K): The new reference object to be associated with this review.
-
-        Returns:
-            ReviewResult[K]: The current instance with updated reference type.
-        """
-        self._ref = ref  # pyright: ignore [reportAttributeAccessIssue]
-        return cast("ReviewResult[K]", self)
-
-    def deref(self) -> T:
-        """Retrieve the referenced object that was reviewed.
-
-        Returns:
-            T: The original object that was reviewed.
-        """
-        return self._ref
-
-    async def supervisor_check(self, check_solutions: bool = True) -> Self:
-        """Perform an interactive review session to filter problems and solutions.
-
-        Presents an interactive prompt allowing a supervisor to select which
-        problems (and optionally solutions) should be retained in the final review.
-
-        Args:
-            check_solutions (bool, optional): When True, also prompts for filtering
-                individual solutions for each retained problem. Defaults to False.
-
-        Returns:
-            Self: The current instance with filtered problems and solutions.
-        """
-        if isinstance(self._ref, str):
-            display = self._ref
-        elif isinstance(self._ref, WithBriefing):
-            display = self._ref.briefing
-        elif isinstance(self._ref, Display):
-            display = self._ref.display()
-        else:
-            raise TypeError(f"Unsupported type for review: {type(self._ref)}")
-        # Choose the problems to retain
-        r_print(display)
-        chosen_ones: List[ProblemSolutions] = await checkbox(
-            f"Please choose the problems you want to retain.(Default: retain all)\n\t`{self.review_topic}`",
-            choices=[Choice(p.problem, p, checked=True) for p in self.problem_solutions],
-        ).ask_async()
-        self.problem_solutions = [await p.edit_problem() for p in chosen_ones]
-        if not check_solutions:
-            return self
-
-        # Choose the solutions to retain
-        for to_exam in self.problem_solutions:
-            to_exam.update_solutions(
-                await checkbox(
-                    f"Please choose the solutions you want to retain.(Default: retain all)\n\t`{to_exam.problem}`",
-                    choices=[Choice(s, s, checked=True) for s in to_exam.solutions],
-                ).ask_async()
-            )
-            await to_exam.edit_solutions()
-
-        return self
-
-
-class Review(GiveRating, Propose):
+class Review(Rating, Propose):
     """Class that provides functionality to review tasks and strings using a language model.
 
     This class extends GiveRating and Propose capabilities to analyze content,
@@ -185,7 +23,7 @@ class Review(GiveRating, Propose):
     appropriate topic and criteria.
     """
 
-    async def review_task[T](self, task: Task[T], **kwargs: Unpack[ReviewKwargs]) -> ReviewResult[Task[T]]:
+    async def review_task[T](self, task: Task[T], **kwargs: Unpack[ReviewKwargs]) -> Optional[Improvement]:
         """Review a task using specified review criteria.
 
         This method analyzes a task object to identify problems and propose solutions
@@ -197,10 +35,10 @@ class Review(GiveRating, Propose):
                 including topic and optional criteria.
 
         Returns:
-            ReviewResult[Task[T]]: A review result containing identified problems and proposed solutions,
+            Improvement[Task[T]]: A review result containing identified problems and proposed solutions,
                 with a reference to the original task.
         """
-        return cast("ReviewResult[Task[T]]", await self.review_obj(task, **kwargs))
+        return await self.review_obj(task, **kwargs)
 
     async def review_string(
         self,
@@ -208,8 +46,8 @@ class Review(GiveRating, Propose):
         topic: str,
         criteria: Optional[Set[str]] = None,
         rating_manual: Optional[Dict[str, str]] = None,
-        **kwargs: Unpack[ValidateKwargs[ReviewResult[str]]],
-    ) -> ReviewResult[str]:
+        **kwargs: Unpack[ValidateKwargs[Improvement]],
+    ) -> Optional[Improvement]:
         """Review a string based on specified topic and criteria.
 
         This method analyzes a text string to identify problems and propose solutions
@@ -224,7 +62,7 @@ class Review(GiveRating, Propose):
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            ReviewResult[str]: A review result containing identified problems and proposed solutions,
+            Improvement: A review result containing identified problems and proposed solutions,
                 with a reference to the original text.
         """
         default = None
@@ -232,28 +70,21 @@ class Review(GiveRating, Propose):
             # this `default` is the default for the `propose` method
             default = kwargs.pop("default")
 
-        criteria = criteria or (await self.draft_rating_criteria(topic, **kwargs))
-        if not criteria:
-            raise ValueError("No criteria provided for review.")
+        criteria = ok(criteria or (await self.draft_rating_criteria(topic, **kwargs))," No criteria could be use.")
         manual = rating_manual or await self.draft_rating_manual(topic, criteria, **kwargs)
 
         if default is not None:
             kwargs["default"] = default
-        res = await self.propose(
-            ReviewResult,
+        return await self.propose(
+            Improvement,
             TEMPLATE_MANAGER.render_template(
                 configs.templates.review_string_template,
                 {"text": input_text, "topic": topic, "criteria_manual": manual},
             ),
             **kwargs,
         )
-        if not res:
-            raise ValueError("Failed to generate review result.")
-        return res.update_ref(input_text).update_topic(topic)
 
-    async def review_obj[M: (Display, WithBriefing)](
-        self, obj: M, **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]]
-    ) -> ReviewResult[M]:
+    async def review_obj[M: (Display, WithBriefing)](self, obj: M, **kwargs: Unpack[ReviewKwargs[Improvement]]) -> Optional[Improvement]:
         """Review an object that implements Display or WithBriefing interface.
 
         This method extracts displayable text from the object and performs a review
@@ -268,14 +99,14 @@ class Review(GiveRating, Propose):
             TypeError: If the object does not implement Display or WithBriefing.
 
         Returns:
-            ReviewResult[M]: A review result containing identified problems and proposed solutions,
+            Improvement: A review result containing identified problems and proposed solutions,
                 with a reference to the original object.
         """
         if isinstance(obj, Display):
-            text = obj.display()
+            text_to_review = obj.display()
         elif isinstance(obj, WithBriefing):
-            text = obj.briefing
+            text_to_review = obj.briefing
         else:
             raise TypeError(f"Unsupported type for review: {type(obj)}")
 
-        return (await self.review_string(text, **kwargs)).update_ref(obj)
+        return await self.review_string(text_to_review, **kwargs)

fabricatio/capabilities/task.py

@@ -1,22 +1,21 @@
 """A module for the task capabilities of the Fabricatio library."""
 
 from types import CodeType
-from typing import Any, Dict, List, Optional, Tuple, Unpack, cast
+from typing import Any, Dict, List, Optional, Tuple, Unpack
 
 import orjson
-from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
 from fabricatio.config import configs
 from fabricatio.journal import logger
-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 ToolBoxUsage
 from fabricatio.parser import JsonCapture, PythonCapture
+from fabricatio.rust_instances import TEMPLATE_MANAGER
 
 
-class ProposeTask(WithBriefing, Propose):
+class ProposeTask(Propose):
     """A class that proposes a task based on a prompt."""
 
     async def propose_task[T](
@@ -34,13 +33,13 @@ class ProposeTask(WithBriefing, Propose):
             A Task object based on the proposal result.
         """
         if not prompt:
-            logger.error(err := f"{self.name}: Prompt must be provided.")
+            logger.error(err := "Prompt must be provided.")
             raise ValueError(err)
 
-        return await self.propose(Task, prompt, **self.prepend_sys_msg(cast("Dict[str, Any]", kwargs)))
+        return await self.propose(Task, prompt, **kwargs)
 
 
-class HandleTask(WithBriefing, ToolBoxUsage):
+class HandleTask(ToolBoxUsage):
     """A class that handles a task based on a task object."""
 
     async def draft_tool_usage_code(
@@ -54,7 +53,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         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."
+            err = "Tools must be provided to draft the tool usage code."
             logger.error(err)
             raise ValueError(err)
 
@@ -81,7 +80,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         return await self.aask_validate(
             question=q,
             validator=_validator,
-            **self.prepend_sys_msg(cast("Dict[str, Any]", kwargs)),
+            **kwargs,
         )
 
     async def handle_fine_grind(
@@ -96,7 +95,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         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]}")
+        logger.info(f"Gathered {[t.name for t in tools]}")
 
         if tools and (pack := await self.draft_tool_usage_code(task, tools, data, **kwargs)):
             executor = ToolExecutor(candidates=tools, data=data)

fabricatio/config.py

@@ -229,15 +229,23 @@ class TemplateConfig(BaseModel):
     generic_string_template: str = Field(default="generic_string")
     """The name of the generic string template which will be used to review a string."""
 
-    correct_template: str = Field(default="correct")
-    """The name of the correct template which will be used to correct a string."""
-
     co_validation_template: str = Field(default="co_validation")
     """The name of the co-validation template which will be used to co-validate a string."""
 
     as_prompt_template: str = Field(default="as_prompt")
     """The name of the as prompt template which will be used to convert a string to a prompt."""
 
+    check_string_template: str = Field(default="check_string")
+    """The name of the check string template which will be used to check a string."""
+
+    ruleset_requirement_breakdown_template: str = Field(default="ruleset_requirement_breakdown")
+    """The name of the ruleset requirement breakdown template which will be used to breakdown a ruleset requirement."""
+
+    fix_troubled_obj_template: str = Field(default="fix_troubled_obj")
+    """The name of the fix troubled object template which will be used to fix a troubled object."""
+
+    fix_troubled_string_template: str = Field(default="fix_troubled_string")
+    """The name of the fix troubled string template which will be used to fix a troubled string."""
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""

fabricatio/fs/curd.py

@@ -145,5 +145,9 @@ def gather_files(directory: str | Path | PathLike, extension: str) -> list[str]:
 
     Returns:
         list[str]: A list of file paths with the specified extension.
+
+    Example:
+        >>> gather_files('/path/to/directory', 'txt')
+        ['/path/to/directory/file1.txt', '/path/to/directory/file2.txt']
     """
     return [file.as_posix() for file in Path(directory).rglob(f"*.{extension}")]

fabricatio/models/action.py

@@ -9,16 +9,18 @@ from abc import abstractmethod
 from asyncio import Queue, create_task
 from typing import Any, Dict, Self, Tuple, Type, Union, final
 
-from fabricatio.capabilities.correct import Correct
-from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.task import Task
-from fabricatio.models.usages import ToolBoxUsage
+from fabricatio.models.usages import LLMUsage, ToolBoxUsage
 from pydantic import Field, PrivateAttr
 
+OUTPUT_KEY = "task_output"
 
-class Action(HandleTask, ProposeTask, Correct):
+INPUT_KEY = "task_input"
+
+
+class Action(WithBriefing, LLMUsage):
     """Class that represents an action to be executed in a workflow.
 
     Actions are the atomic units of work in a workflow. Each action performs
@@ -90,6 +92,10 @@ class Action(HandleTask, ProposeTask, Correct):
             return f"## Your personality: \n{self.personality}\n# The action you are going to perform: \n{super().briefing}"
         return f"# The action you are going to perform: \n{super().briefing}"
 
+    def to_task_output(self)->Self:
+        """Set the output key to OUTPUT_KEY and return the action instance."""
+        self.output_key=OUTPUT_KEY
+        return self
 
 class WorkFlow(WithBriefing, ToolBoxUsage):
     """Class that represents a sequence of actions to be executed for a task.
@@ -98,19 +104,24 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     a shared context between them and handling task lifecycle events.
     """
 
+    description: str = ""
+    """The description of the workflow, which describes the workflow's purpose and requirements."""
+
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
     """Queue for storing the workflow execution context."""
 
     _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
     """Instantiated action objects to be executed in this workflow."""
 
-    steps: Tuple[Union[Type[Action], Action], ...] = Field(...)
+    steps: Tuple[Union[Type[Action], Action], ...] = Field(
+        frozen=True,
+    )
     """The sequence of actions to be executed, can be action classes or instances."""
 
-    task_input_key: str = Field(default="task_input")
+    task_input_key: str = Field(default=INPUT_KEY)
     """Key used to store the input task in the context dictionary."""
 
-    task_output_key: str = Field(default="task_output")
+    task_output_key: str = Field(default=OUTPUT_KEY)
     """Key used to extract the final result from the context dictionary."""
 
     extra_init_context: Dict[str, Any] = Field(default_factory=dict, frozen=True)
@@ -157,19 +168,22 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
             # Process each action in sequence
             for step in self._instances:
                 current_action = step.name
-                logger.info(f"Executing step: {current_action}")
+                logger.info(f"Executing step >> {current_action}")
 
                 # Get current context and execute action
                 context = await self._context.get()
                 act_task = create_task(step.act(context))
                 # Handle task cancellation
                 if task.is_cancelled():
+                    logger.warning(f"Task cancelled by task: {task.name}")
                     act_task.cancel(f"Cancelled by task: {task.name}")
                     break
 
                 # Update context with modified values
                 modified_ctx = await act_task
                 logger.success(f"Step execution finished: {current_action}")
+                if step.output_key:
+                    logger.success(f"Setting output to `{step.output_key}`")
                 await self._context.put(modified_ctx)
 
             logger.success(f"Workflow execution finished: {self.name}")
@@ -180,7 +194,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
 
             if self.task_output_key not in final_ctx:
                 logger.warning(
-                    f"Task output key: {self.task_output_key} not found in the context, None will be returned. "
+                    f"Task output key: `{self.task_output_key}` not found in the context, None will be returned. "
                     f"You can check if `Action.output_key` is set the same as `WorkFlow.task_output_key`."
                 )
 
@@ -219,7 +233,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         self.provide_tools_to(self._instances)
         return self
 
-    def update_init_context(self, **kwargs) -> Self:
+    def update_init_context(self, /, **kwargs) -> Self:
         """Update the initial context with additional key-value pairs.
 
         Args:

fabricatio/models/adv_kwargs_types.py

@@ -0,0 +1,25 @@
+"""A module containing kwargs types for content correction and checking operations."""
+from fabricatio.models.extra.problem import Improvement
+from fabricatio.models.extra.rule import RuleSet
+from fabricatio.models.generic import SketchedAble
+from fabricatio.models.kwargs_types import ReferencedKwargs
+
+
+class CorrectKwargs[T: SketchedAble](ReferencedKwargs[T], total=False):
+    """Arguments for content correction operations.
+
+    Extends GenerateKwargs with parameters for correcting content based on
+    specific criteria and templates.
+    """
+
+    improvement: Improvement
+
+
+class CheckKwargs(ReferencedKwargs[Improvement], total=False):
+    """Arguments for content checking operations.
+
+    Extends GenerateKwargs with parameters for checking content against
+    specific criteria and templates.
+    """
+
+    ruleset: RuleSet

fabricatio/models/extra/__init__.py

@@ -0,0 +1 @@
+"""A module contains extra models for fabricatio."""

fabricatio/models/extra/advanced_judge.py

@@ -0,0 +1,32 @@
+"""Module containing the JudgeMent class for holding judgment results."""
+
+from typing import List
+
+from fabricatio.models.generic import Display, ProposedAble
+
+
+class JudgeMent(ProposedAble, Display):
+    """Represents a judgment result containing supporting/denying evidence and final verdict.
+
+    The class stores both affirmative and denies evidence, truth and reasons lists along with the final boolean judgment.
+    """
+
+    issue_to_judge: str
+    """The issue to be judged"""
+
+    deny_evidence: List[str]
+    """List of clues supporting the denial."""
+
+    affirm_evidence: List[str]
+    """List of clues supporting the affirmation."""
+
+    final_judgement: bool
+    """The final judgment made according to all extracted clues."""
+
+    def __bool__(self) -> bool:
+        """Return the final judgment value.
+
+        Returns:
+            bool: The stored final_judgement value indicating the judgment result.
+        """
+        return self.final_judgement