fabricatio 0.2.8.dev3__cp312-cp312-win_amd64.whl → 0.2.9.dev0__cp312-cp312-win_amd64.whl

fabricatio/capabilities/check.py

@@ -1,10 +1,12 @@
 """A class that provides the capability to check strings and objects against rules and guidelines."""
+
 from typing import Optional, Unpack
 
 from fabricatio import TEMPLATE_MANAGER
 from fabricatio.capabilities.advanced_judge import AdvancedJudge
 from fabricatio.capabilities.propose import Propose
 from fabricatio.config import configs
+from fabricatio.models.extra.patches import RuleSetBriefingPatch
 from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.extra.rule import Rule, RuleSet
 from fabricatio.models.generic import Display, WithBriefing
@@ -13,49 +15,80 @@ from fabricatio.utils import override_kwargs
 
 
 class Check(AdvancedJudge, Propose):
-    """Class that provides the capability to validate strings/objects against predefined rules and guidelines."""
+    """Class for validating strings/objects against predefined rules and guidelines.
+
+    This capability combines rule-based judgment and proposal generation to provide
+    structured validation results with actionable improvement suggestions.
+    """
 
     async def draft_ruleset(
-        self, ruleset_requirement: str, **kwargs: Unpack[ValidateKwargs[RuleSet]]
+        self, ruleset_requirement: str, rule_count: int = 0, **kwargs: Unpack[ValidateKwargs[Rule]]
     ) -> Optional[RuleSet]:
-        """Generate a rule set based on specified requirements.
+        """Generate rule set based on requirement description.
 
         Args:
-            ruleset_requirement (str): Description of desired rule set characteristics
-            **kwargs: Validation configuration parameters
+            ruleset_requirement (str): Natural language description of desired ruleset characteristics
+            rule_count (int): Number of rules to generate (0 for default count)
+            **kwargs: Validation parameters for rule generation
 
         Returns:
-            Optional[RuleSet]: Generated rule set if successful
+            Optional[RuleSet]: Validated ruleset object or None if generation fails
+
+        Notes:
+            - Requires valid template configuration in configs.templates
+            - Returns None if any step in rule generation fails
+            - Uses `alist_str` for requirement breakdown and iterative rule proposal
         """
-        return await self.propose(RuleSet, ruleset_requirement, **kwargs)
+        rule_reqs = await self.alist_str(
+            TEMPLATE_MANAGER.render_template(
+                configs.templates.ruleset_requirement_breakdown_template, {"ruleset_requirement": ruleset_requirement}
+            ),
+            rule_count,
+            **override_kwargs(kwargs, default=None),
+        )
 
-    async def draft_rule(self, rule_requirement: str, **kwargs: Unpack[ValidateKwargs[Rule]]) -> Optional[Rule]:
-        """Create a specific rule based on given specifications.
+        if rule_reqs is None:
+            return None
 
-        Args:
-            rule_requirement (str): Detailed rule description requirements
-            **kwargs: Validation configuration parameters
+        rules = await self.propose(Rule, [TEMPLATE_MANAGER.render_template(configs.templates.rule_requirement_template, {"rule_requirement": r}) for r in rule_reqs], **kwargs)
+        if any(r for r in rules if r is None):
+            return None
 
-        Returns:
-            Optional[Rule]: Generated rule instance if successful
-        """
-        return await self.propose(Rule, rule_requirement, **kwargs)
+        ruleset_patch = await self.propose(
+            RuleSetBriefingPatch,
+            f"# Rules Requirements\n{rule_reqs}\n# Generated Rules\n{Display.seq_display(rules)}\n\n"
+            f"You need to write a concise and detailed patch for this ruleset that can be applied to the ruleset nicely.\n"
+            f"Note that all fields in this patch will be directly copied to the ruleset obj, including `name` and `description`, so write when knowing the subject.\n",
+            **override_kwargs(kwargs, default=None),
+        )
 
-    async def check_string(
+        if ruleset_patch is None:
+            return None
+
+        return RuleSet(rules=rules, **ruleset_patch.as_kwargs())
+
+    async def check_string_against_rule(
         self,
         input_text: str,
         rule: Rule,
+        reference: str = "",
         **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[Improvement]:
-        """Evaluate text against a specific rule.
+        """Validate text against specific rule.
 
         Args:
-            input_text (str): Text content to be evaluated
-            rule (Rule): Rule instance used for validation
-            **kwargs: Validation configuration parameters
+            input_text (str): Text content to validate
+            rule (Rule): Rule instance for validation
+            reference (str): Reference text for comparison (default: "")
+            **kwargs: Configuration for validation process
 
         Returns:
-            Optional[Improvement]: Suggested improvement if violations found, else None
+            Optional[Improvement]: Suggested improvement if violation detected
+
+        Notes:
+            - Uses `evidently_judge` to determine violation presence
+            - Renders template using `check_string_template` for proposal
+            - Proposes Improvement only when violation is confirmed
         """
         if judge := await self.evidently_judge(
             f"# Content to exam\n{input_text}\n\n# Rule Must to follow\n{rule.display()}\nDoes `Content to exam` provided above violate the `Rule Must to follow` provided above?",
@@ -65,27 +98,34 @@ class Check(AdvancedJudge, Propose):
                 Improvement,
                 TEMPLATE_MANAGER.render_template(
                     configs.templates.check_string_template,
-                    {"to_check": input_text, "rule": rule, "judge": judge.display()},
+                    {"to_check": input_text, "rule": rule, "judge": judge.display(), "reference": reference},
                 ),
                 **kwargs,
             )
         return None
 
-    async def check_obj[M: (Display, WithBriefing)](
+    async def check_obj_against_rule[M: (Display, WithBriefing)](
         self,
         obj: M,
         rule: Rule,
+        reference: str = "",
         **kwargs: Unpack[ValidateKwargs[Improvement]],
     ) -> Optional[Improvement]:
-        """Validate an object against specified rule.
+        """Validate object against rule using text representation.
 
         Args:
-            obj (M): Object implementing Display or WithBriefing interface
-            rule (Rule): Validation rule to apply
+            obj (M): Object implementing Display/WithBriefing interface
+            rule (Rule): Validation rule
+            reference (str): Reference text for comparison (default: "")
             **kwargs: Validation configuration parameters
 
         Returns:
-            Optional[Improvement]: Improvement suggestion if issues detected
+            Optional[Improvement]: Improvement suggestion if issues found
+
+        Notes:
+            - Requires obj to implement display() or briefing property
+            - Raises TypeError for incompatible object types
+            - Converts object to text before string validation
         """
         if isinstance(obj, Display):
             input_text = obj.display()
@@ -94,4 +134,62 @@ class Check(AdvancedJudge, Propose):
         else:
             raise TypeError("obj must be either Display or WithBriefing")
 
-        return await self.check_string(input_text, rule, **kwargs)
+        return await self.check_string_against_rule(input_text, rule, reference, **kwargs)
+
+    async def check_string(
+        self,
+        input_text: str,
+        ruleset: RuleSet,
+        reference: str = "",
+        **kwargs: Unpack[ValidateKwargs[Improvement]],
+    ) -> Optional[Improvement]:
+        """Validate text against full ruleset.
+
+        Args:
+            input_text (str): Text content to validate
+            ruleset (RuleSet): Collection of validation rules
+            reference (str): Reference text for comparison
+            **kwargs: Validation configuration parameters
+
+        Returns:
+            Optional[Improvement]: First detected improvement
+
+        Notes:
+            - Checks rules sequentially and returns first violation
+            - Halts validation after first successful improvement proposal
+            - Maintains rule execution order from ruleset.rules list
+        """
+        imp_seq = [
+            await self.check_string_against_rule(input_text, rule, reference, **kwargs) for rule in ruleset.rules
+        ]
+        if all(isinstance(i, Improvement) for i in imp_seq):
+            return Improvement.gather(*imp_seq)  # pyright: ignore [reportArgumentType]
+        return None
+
+    async def check_obj[M: (Display, WithBriefing)](
+        self,
+        obj: M,
+        ruleset: RuleSet,
+        reference: str = "",
+        **kwargs: Unpack[ValidateKwargs[Improvement]],
+    ) -> Optional[Improvement]:
+        """Validate object against full ruleset.
+
+        Args:
+            obj (M): Object implementing Display/WithBriefing interface
+            ruleset (RuleSet): Collection of validation rules
+            reference (str): Reference text for comparison (default: "")
+            **kwargs: Validation configuration parameters
+
+        Returns:
+            Optional[Improvement]: First detected improvement
+
+        Notes:
+            - Uses check_obj_against_rule for individual rule checks
+            - Maintains same early termination behavior as check_string
+            - Validates object through text conversion mechanism
+        """
+        imp_seq = [await self.check_obj_against_rule(obj, rule, reference, **kwargs) for rule in ruleset.rules]
+        if all(isinstance(i, Improvement) for i in imp_seq):
+            return Improvement.gather(*imp_seq)  # pyright: ignore [reportArgumentType]
+        return None

fabricatio/capabilities/correct.py

@@ -1,160 +1,203 @@
-"""Correct capability module providing advanced review and validation functionality.
+"""A module containing the Correct capability for reviewing, validating, and improving objects."""
 
-This module implements the Correct capability, which extends the Review functionality
-to provide mechanisms for reviewing, validating, and correcting various objects and tasks
-based on predefined criteria and templates.
-"""
+from typing import Optional, Type, Unpack, cast
 
-from typing import Optional, Unpack, cast
-
-from fabricatio._rust_instances import TEMPLATE_MANAGER
-from fabricatio.capabilities.review import Review
+from fabricatio.capabilities.propose import Propose
+from fabricatio.capabilities.rating import Rating
 from fabricatio.config import configs
-from fabricatio.models.extra.problem import Improvement
-from fabricatio.models.generic import CensoredAble, Display, ProposedAble, ProposedUpdateAble, WithBriefing
-from fabricatio.models.kwargs_types import CensoredCorrectKwargs, CorrectKwargs, ReviewKwargs
-from fabricatio.models.task import Task
-from questionary import confirm, text
-from rich import print as rprint
+from fabricatio.journal import logger
+from fabricatio.models.adv_kwargs_types import CorrectKwargs
+from fabricatio.models.extra.problem import Improvement, ProblemSolutions
+from fabricatio.models.generic import ProposedUpdateAble, SketchedAble
+from fabricatio.models.kwargs_types import (
+    BestKwargs,
+    ValidateKwargs,
+)
+from fabricatio.rust_instances import TEMPLATE_MANAGER
+from fabricatio.utils import ok, override_kwargs
+
+
+class Correct(Rating, Propose):
+    """A class that provides the capability to correct objects."""
+
+    async def decide_solution(
+        self, problem_solutions: ProblemSolutions, **kwargs: Unpack[BestKwargs]
+    ) -> ProblemSolutions:
+        """Decide the best solution from a list of problem solutions.
+
+        Args:
+            problem_solutions (ProblemSolutions): The problem solutions to evaluate.
+            **kwargs (Unpack[BestKwargs]): Additional keyword arguments for the decision process.
 
+        Returns:
+            ProblemSolutions: The problem solutions with the best solution selected.
+        """
+        if (leng := len(problem_solutions.solutions)) == 0:
+            logger.error(f"No solutions found in ProblemSolutions, Skip: {problem_solutions.problem}")
+        if leng > 1:
+            problem_solutions.solutions = await self.best(problem_solutions.solutions, **kwargs)
+        return problem_solutions
 
-class Correct(Review):
-    """Correct capability for reviewing, validating, and improving objects.
+    async def decide_improvement(self, improvement: Improvement, **kwargs: Unpack[BestKwargs]) -> Improvement:
+        """Decide the best solution for each problem solution in an improvement.
 
-    This class enhances the Review capability with specialized functionality for
-    correcting and improving objects based on review feedback. It can process
-    various inputs including tasks, strings, and generic objects that implement
-    the required interfaces, applying corrections based on templated review processes.
-    """
+        Args:
+            improvement (Improvement): The improvement containing problem solutions to evaluate.
+            **kwargs (Unpack[BestKwargs]): Additional keyword arguments for the decision process.
 
-    async def correct_obj[M: ProposedAble](
+        Returns:
+            Improvement: The improvement with the best solutions selected for each problem solution.
+        """
+        if (leng := len(improvement.problem_solutions)) == 0:
+            logger.error(f"No problem_solutions found in Improvement, Skip: {improvement}")
+        if leng > 1:
+            for ps in improvement.problem_solutions:
+                ps.solutions = await self.best(ps.solutions, **kwargs)
+        return improvement
+
+    async def fix_troubled_obj[M: SketchedAble](
         self,
         obj: M,
+        problem_solutions: ProblemSolutions,
         reference: str = "",
-        supervisor_check: bool = True,
-        **kwargs: Unpack[ReviewKwargs[Improvement]],
+        **kwargs: Unpack[ValidateKwargs[M]],
     ) -> Optional[M]:
-        """Review and correct an object based on defined criteria and templates.
-
-        This method first conducts a review of the given object, then uses the review results
-        to generate a corrected version of the object using appropriate templates.
+        """Fix a troubled object based on problem solutions.
 
         Args:
-            obj (M): The object to be reviewed and corrected. Must implement ProposedAble.
+            obj (M): The object to be fixed.
+            problem_solutions (ProblemSolutions): The problem solutions to apply.
             reference (str): A reference or contextual information for the object.
-            supervisor_check (bool, optional): Whether to perform a supervisor check on the review results. Defaults to True.
-            **kwargs: Review configuration parameters including criteria and review options.
+            **kwargs (Unpack[ValidateKwargs[M]]): Additional keyword arguments for the validation process.
 
         Returns:
-            Optional[M]: A corrected version of the input object, or None if correction fails.
-
-        Raises:
-            TypeError: If the provided object doesn't implement Display or WithBriefing interfaces.
+            Optional[M]: The fixed object, or None if fixing fails.
         """
-        if not isinstance(obj, (Display, WithBriefing)):
-            raise TypeError(f"Expected Display or WithBriefing, got {type(obj)}")
-
-        review_res = await self.review_obj(obj, **kwargs)
-        if supervisor_check:
-            await review_res.supervisor_check()
-        if "default" in kwargs:
-            cast("ReviewKwargs[None]", kwargs)["default"] = None
         return await self.propose(
-            obj.__class__,
+            cast("Type[M]", obj.__class__),
             TEMPLATE_MANAGER.render_template(
-                configs.templates.correct_template,
+                configs.templates.fix_troubled_obj_template,
                 {
-                    "content": f"{(reference + '\n\nAbove is referencing material') if reference else ''}{obj.display() if isinstance(obj, Display) else obj.briefing}",
-                    "review": review_res.display(),
+                    "problem": problem_solutions.problem,
+                    "solution": ok(
+                        problem_solutions.final_solution(),
+                        f"No solution found for problem: {problem_solutions.problem}",
+                    ),
+                    "reference": reference,
                 },
             ),
             **kwargs,
         )
 
-    async def correct_string(
-        self, input_text: str, supervisor_check: bool = True, **kwargs: Unpack[ReviewKwargs[Improvement]]
+    async def fix_troubled_string(
+        self,
+        input_text: str,
+        problem_solutions: ProblemSolutions,
+        reference: str = "",
+        **kwargs: Unpack[ValidateKwargs[str]],
     ) -> Optional[str]:
-        """Review and correct a string based on defined criteria and templates.
-
-        This method applies the review process to the input text and generates
-        a corrected version based on the review results.
+        """Fix a troubled string based on problem solutions.
 
         Args:
-            input_text (str): The text content to be reviewed and corrected.
-            supervisor_check (bool, optional): Whether to perform a supervisor check on the review results. Defaults to True.
-            **kwargs: Review configuration parameters including criteria and review options.
+            input_text (str): The string to be fixed.
+            problem_solutions (ProblemSolutions): The problem solutions to apply.
+            reference (str): A reference or contextual information for the string.
+            **kwargs (Unpack[ValidateKwargs[str]]): Additional keyword arguments for the validation process.
 
         Returns:
-            Optional[str]: The corrected text content, or None if correction fails.
+            Optional[str]: The fixed string, or None if fixing fails.
         """
-        review_res = await self.review_string(input_text, **kwargs)
-        if supervisor_check:
-            await review_res.supervisor_check()
-
-        if "default" in kwargs:
-            cast("ReviewKwargs[None]", kwargs)["default"] = None
         return await self.ageneric_string(
             TEMPLATE_MANAGER.render_template(
-                configs.templates.correct_template, {"content": input_text, "review": review_res.display()}
+                configs.templates.fix_troubled_string_template,
+                {
+                    "problem": problem_solutions.problem,
+                    "solution": ok(
+                        problem_solutions.final_solution(),
+                        f"No solution found for problem: {problem_solutions.problem}",
+                    ),
+                    "reference": reference,
+                    "string_to_fix": input_text,
+                },
             ),
             **kwargs,
         )
 
-    async def correct_task[T](
-        self, task: Task[T], **kwargs: Unpack[CorrectKwargs[Improvement]]
-    ) -> Optional[Task[T]]:
-        """Review and correct a task object based on defined criteria.
+    async def correct_obj[M: SketchedAble](
+        self,
+        obj: M,
+        improvement: Improvement,
+        reference: str = "",
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> Optional[M]:
+        """Review and correct an object based on defined criteria and templates.
 
-        This is a specialized version of correct_obj specifically for Task objects,
-        applying the same review and correction process to task definitions.
+        This method first conducts a review of the given object, then uses the review results
+        to generate a corrected version of the object using appropriate templates.
 
         Args:
-            task (Task[T]): The task to be reviewed and corrected.
-            **kwargs: Review configuration parameters including criteria and review options.
+            obj (M): The object to be reviewed and corrected. Must implement ProposedAble.
+            improvement (Improvement): The improvement object containing the review results.
+            reference (str): A reference or contextual information for the object.
+            **kwargs (Unpack[ValidateKwargs[M]]): Review configuration parameters including criteria and review options.
 
         Returns:
-            Optional[Task[T]]: The corrected task, or None if correction fails.
+            Optional[M]: A corrected version of the input object, or None if correction fails.
+
+        Raises:
+            TypeError: If the provided object doesn't implement Display or WithBriefing interfaces.
         """
-        return await self.correct_obj(task, **kwargs)
+        if not improvement.decided():
+            improvement = await self.decide_improvement(improvement, **override_kwargs(kwargs, default=None))
+
+        for ps in improvement.problem_solutions:
+            fixed_obj = await self.fix_troubled_obj(obj, ps, reference, **kwargs)
+            if fixed_obj is None:
+                logger.error(
+                    f"Failed to fix troubling obj {obj.__class__.__name__} when deal with problem: {ps.problem}",
+                )
+                return None
+            obj = fixed_obj
+        return obj
+
+    async def correct_string(
+        self, input_text: str, improvement: Improvement, reference: str = "", **kwargs: Unpack[ValidateKwargs[str]]
+    ) -> Optional[str]:
+        """Review and correct a string based on defined criteria and templates.
 
-    async def censor_obj[M: CensoredAble](
-        self, obj: M, **kwargs: Unpack[CensoredCorrectKwargs[Improvement]]
-    ) -> M:
-        """Censor and correct an object based on defined criteria and templates.
+        This method first conducts a review of the given string, then uses the review results
+        to generate a corrected version of the string using appropriate templates.
 
         Args:
-            obj (M): The object to be reviewed and corrected.
-            **kwargs (Unpack[CensoredCorrectKwargs]): Additional keyword
+            input_text (str): The string to be reviewed and corrected.
+            improvement (Improvement): The improvement object containing the review results.
+            reference (str): A reference or contextual information for the string.
+            **kwargs (Unpack[ValidateKwargs[str]]): Review configuration parameters including criteria and review options.
 
         Returns:
-            M: The censored and corrected object.
+            Optional[str]: A corrected version of the input string, or None if correction fails.
         """
-        last_modified_obj = obj
-        modified_obj = None
-        rprint(obj.finalized_dump())
-        while await confirm("Begin to correct obj above with human censorship?").ask_async():
-            while (topic := await text("What is the topic of the obj reviewing?").ask_async()) is not None and topic:
-                ...
-            if (
-                modified_obj := await self.correct_obj(
-                    last_modified_obj,
-                    topic=topic,
-                    **kwargs,
+        if not improvement.decided():
+            improvement = await self.decide_improvement(improvement, **override_kwargs(kwargs, default=None))
+
+        for ps in improvement.problem_solutions:
+            fixed_string = await self.fix_troubled_string(input_text, ps, reference, **kwargs)
+            if fixed_string is None:
+                logger.error(
+                    f"Failed to fix troubling string when deal with problem: {ps.problem}",
                 )
-            ) is None:
-                break
-            last_modified_obj = modified_obj
-            rprint(last_modified_obj.finalized_dump())
-        return modified_obj or last_modified_obj
+                return None
+            input_text = fixed_string
+        return input_text
 
     async def correct_obj_inplace[M: ProposedUpdateAble](
-        self, obj: M, **kwargs: Unpack[CorrectKwargs[Improvement]]
+        self, obj: M, **kwargs: Unpack[CorrectKwargs[M]]
     ) -> Optional[M]:
         """Correct an object in place based on defined criteria and templates.
 
         Args:
             obj (M): The object to be corrected.
-            **kwargs (Unpack[CensoredCorrectKwargs]): Additional keyword arguments for the correction process.
+            **kwargs (Unpack[CorrectKwargs[M]]): Additional keyword arguments for the correction process.
 
         Returns:
             Optional[M]: The corrected object, or None if correction fails.

fabricatio/capabilities/rag.py

@@ -3,14 +3,16 @@
 try:
     from pymilvus import MilvusClient
 except ImportError as e:
-    raise RuntimeError("pymilvus is not installed. Have you installed `fabricatio[rag]` instead of `fabricatio`") from e
+    raise RuntimeError("pymilvus is not installed. Have you installed `fabricatio[rag]` instead of `fabricatio`?") from e
 from functools import lru_cache
 from operator import itemgetter
 from os import PathLike
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Self, Union, Unpack, cast, overload
 
-from fabricatio._rust_instances import TEMPLATE_MANAGER
+from more_itertools.recipes import flatten, unique
+from pydantic import Field, PrivateAttr
+
 from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.kwargs_types import (
@@ -23,9 +25,8 @@ from fabricatio.models.kwargs_types import (
 )
 from fabricatio.models.usages import EmbeddingUsage
 from fabricatio.models.utils import MilvusData
+from fabricatio.rust_instances import TEMPLATE_MANAGER
 from fabricatio.utils import ok
-from more_itertools.recipes import flatten, unique
-from pydantic import Field, PrivateAttr
 
 
 @lru_cache(maxsize=None)