fabricatio 0.3.15.dev5__cp313-cp313-win_amd64.whl → 0.4.0__cp313-cp313-win_amd64.whl

fabricatio/capabilities/check.py

@@ -1,212 +0,0 @@
-"""A class that provides the capability to check strings and objects against rules and guidelines."""
-
-from abc import ABC
-from asyncio import gather
-from typing import List, Optional, Unpack
-
-from fabricatio.capabilities.advanced_judge import AdvancedJudge
-from fabricatio.capabilities.propose import Propose
-from fabricatio.journal import logger
-from fabricatio.models.extra.patches import RuleSetMetadata
-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.rust import CONFIG, TEMPLATE_MANAGER, detect_language
-from fabricatio.utils import override_kwargs
-
-
-class Check(AdvancedJudge, Propose, ABC):
-    """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(
-                    CONFIG.templates.ruleset_requirement_breakdown_template,
-                    {"ruleset_requirement": ruleset_requirement},
-                ),
-                rule_count,
-                **override_kwargs(kwargs, default=None),
-            )
-            if rule_count > 1
-            else [ruleset_requirement]
-        )
-
-        if rule_reqs is None:
-            return None
-
-        rules = await self.propose(
-            Rule,
-            [
-                TEMPLATE_MANAGER.render_template(CONFIG.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
-
-        ruleset_patch = await self.propose(
-            RuleSetMetadata,
-            f"{ruleset_requirement}\n\nYou should use `{detect_language(ruleset_requirement)}`!",
-            **override_kwargs(kwargs, default=None),
-        )
-
-        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]:
-        """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.name}` provided above?"
-            f"should I take some measure to fix that violation? true for I do need, false for I don't need.",
-            **override_kwargs(kwargs, default=None),
-        ):
-            logger.info(f"Rule `{rule.name}` violated: \n{judge.display()}")
-            return await self.propose(
-                Improvement,
-                TEMPLATE_MANAGER.render_template(
-                    CONFIG.templates.check_string_template,
-                    {"to_check": input_text, "rule": rule.display(), "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[List[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 gather(
-            *[self.check_string_against_rule(input_text, rule, reference, **kwargs) for rule in ruleset.rules]
-        )
-        if imp_seq is None:
-            logger.warning(f"Generation failed for string check against `{ruleset.name}`")
-            return None
-        return [imp for imp in imp_seq if imp]
-
-    async def check_obj[M: (Display, WithBriefing)](
-        self,
-        obj: M,
-        ruleset: RuleSet,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
-    ) -> Optional[List[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 gather(*[self.check_obj_against_rule(obj, rule, reference, **kwargs) for rule in ruleset.rules])
-
-        if imp_seq is None:
-            logger.warning(f"Generation Failed for `{obj.__class__.__name__}` against Ruleset `{ruleset.name}`")
-            return None
-        return [i for i in imp_seq if i]

fabricatio/capabilities/correct.py

@@ -1,228 +0,0 @@
-"""A module containing the Correct capability for reviewing, validating, and improving objects."""
-
-from abc import ABC
-from asyncio import gather
-from typing import Optional, Type, Unpack, cast
-
-from fabricatio.capabilities.propose import Propose
-from fabricatio.capabilities.rating import Rating
-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 import CONFIG, TEMPLATE_MANAGER
-from fabricatio.utils import fallback_kwargs, ok, override_kwargs
-
-
-class Correct(Rating, Propose, ABC):
-    """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.name}`")
-        if leng > 1:
-            logger.info(f"{leng} solutions found in Problem `{problem_solutions.problem.name}`, select the best.")
-            problem_solutions.solutions = await self.best(problem_solutions.solutions, **kwargs)
-        return problem_solutions
-
-    async def decide_improvement(self, improvement: Improvement, **kwargs: Unpack[BestKwargs]) -> Improvement:
-        """Decide the best solution for each problem solution in an improvement.
-
-        Args:
-            improvement (Improvement): The improvement containing problem solutions to evaluate.
-            **kwargs (Unpack[BestKwargs]): Additional keyword arguments for the decision process.
-
-        Returns:
-            Improvement: The improvement with the best solutions selected for each problem solution.
-        """
-        if leng := len(improvement.problem_solutions):
-            logger.debug(f"{leng} problem_solutions found in Improvement, decide solution for each of them.")
-            await gather(
-                *[
-                    self.decide_solution(
-                        ps,
-                        **fallback_kwargs(
-                            kwargs, topic=f"which solution is better to deal this problem {ps.problem.description}\n\n"
-                        ),
-                    )
-                    for ps in improvement.problem_solutions
-                ],
-            )
-            if any(not (violated := ps).decided() for ps in improvement.problem_solutions):
-                logger.error(f"Some problem_solutions are not decided: {violated}")
-            else:
-                logger.success(f"All problem_solutions are decided '{improvement.focused_on}'")
-        else:
-            logger.error(f"No problem_solutions found in Improvement, Skip: {improvement}")
-        return improvement
-
-    async def fix_troubled_obj[M: SketchedAble](
-        self,
-        obj: M,
-        problem_solutions: ProblemSolutions,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[M]],
-    ) -> Optional[M]:
-        """Fix a troubled object based on problem solutions.
-
-        Args:
-            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.
-            **kwargs (Unpack[ValidateKwargs[M]]): Additional keyword arguments for the validation process.
-
-        Returns:
-            Optional[M]: The fixed object, or None if fixing fails.
-        """
-        return await self.propose(
-            cast("Type[M]", obj.__class__),
-            TEMPLATE_MANAGER.render_template(
-                CONFIG.templates.fix_troubled_obj_template,
-                {
-                    "problem": problem_solutions.problem.display(),
-                    "solution": ok(
-                        problem_solutions.final_solution(),
-                        f"{len(problem_solutions.solutions)} solution Found for `{problem_solutions.problem.name}`.",
-                    ).display(),
-                    "reference": reference,
-                },
-            ),
-            **kwargs,
-        )
-
-    async def fix_troubled_string(
-        self,
-        input_text: str,
-        problem_solutions: ProblemSolutions,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[str]],
-    ) -> Optional[str]:
-        """Fix a troubled string based on problem solutions.
-
-        Args:
-            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 fixed string, or None if fixing fails.
-        """
-        return await self.ageneric_string(
-            TEMPLATE_MANAGER.render_template(
-                CONFIG.templates.fix_troubled_string_template,
-                {
-                    "problem": problem_solutions.problem.display(),
-                    "solution": ok(
-                        problem_solutions.final_solution(),
-                        f"No solution found for problem: {problem_solutions.problem}",
-                    ).display(),
-                    "reference": reference,
-                    "string_to_fix": input_text,
-                },
-            ),
-            **kwargs,
-        )
-
-    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 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:
-            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[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.
-        """
-        if not improvement.decided():
-            logger.info(f"Improvement {improvement.focused_on} not decided, start deciding...")
-            improvement = await self.decide_improvement(improvement, **override_kwargs(kwargs, default=None))
-
-        total = len(improvement.problem_solutions)
-        for idx, ps in enumerate(improvement.problem_solutions):
-            logger.info(f"[{idx + 1}/{total}] Fixing {obj.__class__.__name__} for problem `{ps.problem.name}`")
-            fixed_obj = await self.fix_troubled_obj(obj, ps, reference, **kwargs)
-            if fixed_obj is None:
-                logger.error(f"[{idx + 1}/{total}] Failed to fix problem `{ps.problem.name}`")
-                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.
-
-        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:
-            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:
-            Optional[str]: A corrected version of the input string, or None if correction fails.
-        """
-        if not improvement.decided():
-            logger.info(f"Improvement {improvement.focused_on} not decided, start deciding...")
-
-            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}",
-                )
-                return None
-            input_text = fixed_string
-        return input_text
-
-    async def correct_obj_inplace[M: ProposedUpdateAble](
-        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[CorrectKwargs[M]]): Additional keyword arguments for the correction process.
-
-        Returns:
-            Optional[M]: The corrected object, or None if correction fails.
-        """
-        corrected_obj = await self.correct_obj(obj, **kwargs)
-        if corrected_obj is None:
-            return corrected_obj
-        obj.update_from(corrected_obj)
-        return obj

fabricatio/capabilities/extract.py

@@ -1,74 +0,0 @@
-"""A module that provide capabilities for extracting information from a given source to a model."""
-
-from abc import ABC
-from typing import List, Optional, Type, Unpack, overload
-
-from fabricatio import TEMPLATE_MANAGER
-from fabricatio.capabilities.propose import Propose
-from fabricatio.models.generic import ProposedAble
-from fabricatio.models.kwargs_types import ValidateKwargs
-from fabricatio.rust import CONFIG
-
-
-class Extract(Propose, ABC):
-    """A class that extract information from a given source to a model."""
-
-    @overload
-    async def extract[M: ProposedAble](
-        self,
-        cls: Type[M],
-        source: str,
-        extract_requirement: Optional[str] = None,
-        align_language: bool = True,
-        **kwargs: Unpack[ValidateKwargs[M]],
-    ) -> M: ...
-
-    @overload
-    async def extract[M: ProposedAble](
-        self,
-        cls: Type[M],
-        source: str,
-        extract_requirement: Optional[str] = None,
-        align_language: bool = True,
-        **kwargs: Unpack[ValidateKwargs[None]],
-    ) -> Optional[M]: ...
-
-    @overload
-    async def extract[M: ProposedAble](
-        self,
-        cls: Type[M],
-        source: List[str],
-        extract_requirement: Optional[str] = None,
-        align_language: bool = True,
-        **kwargs: Unpack[ValidateKwargs[M]],
-    ) -> List[M]: ...
-
-    @overload
-    async def extract[M: ProposedAble](
-        self,
-        cls: Type[M],
-        source: List[str],
-        extract_requirement: Optional[str] = None,
-        align_language: bool = True,
-        **kwargs: Unpack[ValidateKwargs[None]],
-    ) -> List[Optional[M]]: ...
-
-    async def extract[M: ProposedAble](
-        self,
-        cls: Type[M],
-        source: List[str] | str,
-        extract_requirement: Optional[str] = None,
-        align_language: bool = True,
-        **kwargs: Unpack[ValidateKwargs[Optional[M]]],
-    ) -> M | List[M] | Optional[M] | List[Optional[M]]:
-        """Extract information from a given source to a model."""
-        return await self.propose(
-            cls,
-            prompt=TEMPLATE_MANAGER.render_template(
-                CONFIG.templates.extract_template,
-                [{"source": s, "extract_requirement": extract_requirement} for s in source]
-                if isinstance(source, list)
-                else {"source": source, "extract_requirement": extract_requirement, "align_language": align_language},
-            ),
-            **kwargs,
-        )

fabricatio/capabilities/propose.py

@@ -1,65 +0,0 @@
-"""A module for the task capabilities of the Fabricatio library."""
-from abc import ABC
-from typing import List, Optional, Type, Unpack, overload
-
-from fabricatio.models.generic import ProposedAble
-from fabricatio.models.kwargs_types import ValidateKwargs
-from fabricatio.models.usages import LLMUsage
-
-
-class Propose(LLMUsage,ABC):
-    """A class that proposes an Obj based on a prompt."""
-
-    @overload
-    async def propose[M: ProposedAble](
-        self,
-        cls: Type[M],
-        prompt: List[str],
-        **kwargs: Unpack[ValidateKwargs[None]],
-    ) -> List[Optional[M]]: ...
-
-    @overload
-    async def propose[M: ProposedAble](
-        self,
-        cls: Type[M],
-        prompt: List[str],
-        **kwargs: Unpack[ValidateKwargs[M]],
-    ) -> List[M]: ...
-
-    @overload
-    async def propose[M: ProposedAble](
-        self,
-        cls: Type[M],
-        prompt: str,
-        **kwargs: Unpack[ValidateKwargs[None]],
-    ) -> Optional[M]: ...
-    @overload
-    async def propose[M: ProposedAble](
-        self,
-        cls: Type[M],
-        prompt: str,
-        **kwargs: Unpack[ValidateKwargs[M]],
-    ) -> M: ...
-
-    async def propose[M: ProposedAble](
-        self,
-        cls: Type[M],
-        prompt: List[str] | str,
-        **kwargs: Unpack[ValidateKwargs[Optional[M]]],
-    ) -> Optional[M] | List[Optional[M]] | M | List[M]:
-        """Asynchronously proposes a task based on a given prompt and parameters.
-
-        Parameters:
-            cls: The class type of the task to be proposed.
-            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.
-        """
-        return await self.aask_validate(
-            question=cls.create_json_prompt(prompt),
-            validator=cls.instantiate_from_string,
-            **kwargs,
-        )
-