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

fabricatio/actions/rag.py

@@ -5,7 +5,7 @@ from typing import List, Optional
 from fabricatio.capabilities.rag import RAG
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.generic import PrepareVectorization
+from fabricatio.models.generic import Vectorizable
 from fabricatio.models.task import Task
 from questionary import text
 
@@ -15,7 +15,7 @@ class InjectToDB(Action, RAG):
 
     output_key: str = "collection_name"
 
-    async def _execute[T: PrepareVectorization](
+    async def _execute[T: Vectorizable](
         self, to_inject: Optional[T] | List[Optional[T]], collection_name: str = "my_collection",override_inject:bool=False, **_
     ) -> Optional[str]:
         if not isinstance(to_inject, list):
@@ -27,7 +27,7 @@ class InjectToDB(Action, RAG):
             [
                 t.prepare_vectorization(self.embedding_max_sequence_length)
                 for t in to_inject
-                if isinstance(t, PrepareVectorization)
+                if isinstance(t, Vectorizable)
             ],
         )
 

fabricatio/actions/rules.py

@@ -0,0 +1,39 @@
+"""A module containing the DraftRuleSet action."""
+
+from typing import Optional
+
+from fabricatio.capabilities.check import Check
+from fabricatio.models.action import Action
+from fabricatio.models.extra.rule import RuleSet
+from fabricatio.utils import ok
+
+
+class DraftRuleSet(Action, Check):
+    """Action to draft a ruleset based on a given requirement description."""
+
+    output_key: str = "drafted_ruleset"
+    """The key used to store the drafted ruleset in the context dictionary."""
+
+    ruleset_requirement: Optional[str] = None
+    """The natural language description of the desired ruleset characteristics."""
+    rule_count: int = 0
+    """The number of rules to generate in the ruleset (0 for no restriction)."""
+    async def _execute(
+        self,
+        ruleset_requirement: Optional[str]=None,
+        **_,
+    ) -> Optional[RuleSet]:
+        """Draft a ruleset based on the requirement description.
+
+        Args:
+            ruleset_requirement (str): Natural language description of desired ruleset characteristics
+            rule_count (int): Number of rules to generate (0 for no restriction)
+            **kwargs: Validation parameters for rule generation
+
+        Returns:
+            Optional[RuleSet]: Drafted ruleset object or None if generation fails
+        """
+        return await self.draft_ruleset(
+            ruleset_requirement=ok(ruleset_requirement or self.ruleset_requirement,"No ruleset requirement provided"),
+            rule_count=self.rule_count,
+        )

fabricatio/capabilities/advanced_judge.py

@@ -0,0 +1,23 @@
+"""The Capabilities module for advanced judging."""
+
+from typing import Optional, Unpack
+
+from fabricatio.capabilities.propose import Propose
+from fabricatio.models.extra.advanced_judge import JudgeMent
+from fabricatio.models.kwargs_types import ValidateKwargs
+
+
+class AdvancedJudge(Propose):
+    """A class that judges the evidence and makes a final decision."""
+    async def evidently_judge(
+        self,
+        prompt: str,
+        **kwargs: Unpack[ValidateKwargs[JudgeMent]],
+    ) -> Optional[JudgeMent]:
+        """Judge the evidence and make a final decision."""
+        return await self.propose(
+            JudgeMent,
+            prompt,
+            **kwargs
+        )
+

fabricatio/capabilities/censor.py

@@ -0,0 +1,90 @@
+"""Module for censoring objects and strings based on provided rulesets.
+
+This module includes the Censor class which inherits from both Correct and Check classes.
+It provides methods to censor objects and strings by first checking them against a ruleset and then correcting them if necessary.
+"""
+
+from typing import Optional, Unpack
+
+from fabricatio.capabilities.check import Check
+from fabricatio.capabilities.correct import Correct
+from fabricatio.models.extra.rule import RuleSet
+from fabricatio.models.generic import ProposedUpdateAble, SketchedAble
+from fabricatio.models.kwargs_types import ReferencedKwargs
+from fabricatio.utils import override_kwargs
+
+
+class Censor(Correct, Check):
+    """Class to censor objects and strings based on provided rulesets.
+
+    Inherits from both Correct and Check classes.
+    Provides methods to censor objects and strings by first checking them against a ruleset and then correcting them if necessary.
+
+    Attributes:
+        ruleset (RuleSet): The ruleset to be used for censoring.
+    """
+
+    async def censor_obj[M: SketchedAble](
+        self, obj: M, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[M]]
+    ) -> Optional[M]:
+        """Censors an object based on the provided ruleset.
+
+        Args:
+            obj (M): The object to be censored.
+            ruleset (RuleSet): The ruleset to apply for censoring.
+            **kwargs: Additional keyword arguments to be passed to the check and correct methods.
+
+        Returns:
+            Optional[M]: The censored object if corrections were made, otherwise None.
+
+        Note:
+            This method first checks the object against the ruleset and then corrects it if necessary.
+        """
+        imp = await self.check_obj(obj, ruleset, **override_kwargs(kwargs, default=None))
+        if imp is None:
+            return imp
+        return await self.correct_obj(obj, imp, **kwargs)
+
+    async def censor_string(
+        self, input_text: str, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[str]]
+    ) -> Optional[str]:
+        """Censors a string based on the provided ruleset.
+
+        Args:
+            input_text (str): The string to be censored.
+            ruleset (RuleSet): The ruleset to apply for censoring.
+            **kwargs: Additional keyword arguments to be passed to the check and correct methods.
+
+        Returns:
+            Optional[str]: The censored string if corrections were made, otherwise None.
+
+        Note:
+            This method first checks the string against the ruleset and then corrects it if necessary.
+        """
+        imp = await self.check_string(input_text, ruleset, **override_kwargs(kwargs, default=None))
+        if imp is None:
+            return imp
+        return await self.correct_string(input_text, imp, **kwargs)
+
+    async def censor_obj_inplace[M: ProposedUpdateAble](
+        self, obj: M, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[M]]
+    ) -> Optional[M]:
+        """Censors an object in-place based on the provided ruleset.
+
+        This method modifies the object directly if corrections are needed.
+
+        Args:
+            obj (M): The object to be censored.
+            ruleset (RuleSet): The ruleset to apply for censoring.
+            **kwargs: Additional keyword arguments to be passed to the check and correct methods.
+
+        Returns:
+            Optional[M]: The censored object if corrections were made, otherwise None.
+
+        Note:
+            This method first checks the object against the ruleset and then corrects it in-place if necessary.
+        """
+        imp = await self.check_obj(obj, ruleset, **override_kwargs(kwargs, default=None))
+        if imp is None:
+            return imp
+        return await self.correct_obj_inplace(obj, improvement=imp, **kwargs)

fabricatio/capabilities/check.py

@@ -0,0 +1,195 @@
+"""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 BriefingPatch
+from fabricatio.models.extra.problem import Improvement
+from fabricatio.models.extra.rule import Rule, RuleSet
+from fabricatio.models.generic import Display, WithBriefing
+from fabricatio.models.kwargs_types import ValidateKwargs
+from fabricatio.utils import override_kwargs
+
+
+class Check(AdvancedJudge, Propose):
+    """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, rule_count: int = 0, **kwargs: Unpack[ValidateKwargs[Rule]]
+    ) -> Optional[RuleSet]:
+        """Generate rule set based on requirement description.
+
+        Args:
+            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]: 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
+        """
+        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),
+        )
+
+        if rule_reqs is None:
+            return None
+
+        rules = await self.propose(Rule, rule_reqs, **kwargs)
+        if any(r for r in rules if r is None):
+            return None
+
+        ruleset_patch = await self.propose(
+            BriefingPatch,
+            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),
+        )
+
+        if ruleset_patch is None:
+            return None
+
+        return ruleset_patch.apply(RuleSet(rules=rules, name="", description=""))
+
+    async def check_string_against_rule(
+        self,
+        input_text: str,
+        rule: Rule,
+        reference: str = "",
+        **kwargs: Unpack[ValidateKwargs[Improvement]],
+    ) -> Optional[Improvement]:
+        """Validate text against specific rule.
+
+        Args:
+            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 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?",
+            **override_kwargs(kwargs, default=None),
+        ):
+            return await self.propose(
+                Improvement,
+                TEMPLATE_MANAGER.render_template(
+                    configs.templates.check_string_template,
+                    {"to_check": input_text, "rule": rule, "judge": judge.display(), "reference": reference},
+                ),
+                **kwargs,
+            )
+        return None
+
+    async def check_obj_against_rule[M: (Display, WithBriefing)](
+        self,
+        obj: M,
+        rule: Rule,
+        reference: str = "",
+        **kwargs: Unpack[ValidateKwargs[Improvement]],
+    ) -> Optional[Improvement]:
+        """Validate object against rule using text representation.
+
+        Args:
+            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 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()
+        elif isinstance(obj, WithBriefing):
+            input_text = obj.briefing
+        else:
+            raise TypeError("obj must be either Display or WithBriefing")
+
+        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