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

fabricatio/capabilities/rating.py

@@ -4,15 +4,17 @@ from itertools import permutations
 from random import sample
 from typing import Dict, List, Optional, Set, Tuple, Union, Unpack, overload
 
-from fabricatio._rust_instances import TEMPLATE_MANAGER
+from more_itertools import flatten, windowed
+from pydantic import NonNegativeInt, PositiveInt
+
 from fabricatio.config import configs
 from fabricatio.journal import logger
-from fabricatio.models.kwargs_types import ValidateKwargs
+from fabricatio.models.generic import Display
+from fabricatio.models.kwargs_types import CompositeScoreKwargs, ValidateKwargs
 from fabricatio.models.usages import LLMUsage
 from fabricatio.parser import JsonCapture
-from fabricatio.utils import override_kwargs
-from more_itertools import flatten, windowed
-from pydantic import NonNegativeInt, PositiveInt
+from fabricatio.rust_instances import TEMPLATE_MANAGER
+from fabricatio.utils import ok, override_kwargs
 
 
 class Rating(LLMUsage):
@@ -86,6 +88,7 @@ class Rating(LLMUsage):
         to_rate: str,
         topic: str,
         criteria: Set[str],
+        manual: Optional[Dict[str, str]],
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
     ) -> Dict[str, float]: ...
@@ -96,6 +99,7 @@ class Rating(LLMUsage):
         to_rate: List[str],
         topic: str,
         criteria: Set[str],
+        manual: Optional[Dict[str, str]],
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
     ) -> List[Dict[str, float]]: ...
@@ -105,6 +109,7 @@ class Rating(LLMUsage):
         to_rate: Union[str, List[str]],
         topic: str,
         criteria: Set[str],
+        manual: Optional[Dict[str, str]],
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
     ) -> Optional[Dict[str, float] | List[Dict[str, float]]]:
@@ -114,6 +119,7 @@ class Rating(LLMUsage):
             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.
+            manual (Optional[Dict[str, str]]): A dictionary containing the rating criteria. If not provided, then this method will draft the criteria automatically.
             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.
 
@@ -121,7 +127,11 @@ class Rating(LLMUsage):
             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) or dict(zip(criteria, criteria, strict=True))
+        manual = (
+            manual
+            or await self.draft_rating_manual(topic, criteria, **override_kwargs(kwargs, default=None))
+            or dict(zip(criteria, criteria, strict=True))
+        )
 
         return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
 
@@ -309,7 +319,7 @@ class Rating(LLMUsage):
             validator=lambda resp: JsonCapture.validate_with(resp, target_type=float),
             **kwargs,
         )
-        weights = [1]
+        weights = [1.0]
         for rw in relative_weights:
             weights.append(weights[-1] * rw)
         total = sum(weights)
@@ -319,27 +329,66 @@ class Rating(LLMUsage):
         self,
         topic: str,
         to_rate: List[str],
-        reasons_count: PositiveInt = 2,
-        criteria_count: PositiveInt = 5,
-        **kwargs: Unpack[ValidateKwargs],
+        criteria: Optional[Set[str]] = None,
+        weights: Optional[Dict[str, float]] = None,
+        manual: Optional[Dict[str, str]] = None,
+        **kwargs: Unpack[ValidateKwargs[List[Dict[str, float]]]],
     ) -> 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.
+            criteria (Optional[Set[str]]): A set of criteria for the rating. Defaults to None.
+            weights (Optional[Dict[str, float]]): A dictionary of rating weights for each criterion. Defaults to None.
+            manual (Optional[Dict[str, str]]): A dictionary of manual ratings for each item. Defaults to None.
             **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
+        criteria = ok(
+            criteria
+            or await self.draft_rating_criteria_from_examples(topic, to_rate, **override_kwargs(kwargs, default=None))
+        )
+        weights = ok(
+            weights or await self.drafting_rating_weights_klee(topic, criteria, **override_kwargs(kwargs, default=None))
         )
-        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)
+        ratings_seq = await self.rate(to_rate, topic, criteria, manual, **kwargs)
 
         return [sum(ratings[c] * weights[c] for c in criteria) for ratings in ratings_seq]
+
+    @overload
+    async def best(self, candidates: List[str], k: int=1, **kwargs: Unpack[CompositeScoreKwargs]) -> List[str]: ...
+    @overload
+    async def best[T: Display](
+        self, candidates: List[T], k: int=1, **kwargs: Unpack[CompositeScoreKwargs]
+    ) -> List[T]: ...
+
+    async def best[T: Display](
+        self, candidates: List[str] | List[T], k: int=1, **kwargs: Unpack[CompositeScoreKwargs]
+    ) -> Optional[List[str] | List[T]]:
+        """Choose the best candidates from the list of candidates based on the composite score.
+
+        Args:
+            k (int): The number of best candidates to choose.
+            candidates (List[str]): A list of candidates to choose from.
+            **kwargs (CompositeScoreKwargs): Additional keyword arguments for the composite score calculation.
+
+        Returns:
+            List[str]: The best candidates.
+        """
+        if (leng := len(candidates)) == 0:
+            logger.warning(f"No candidates, got {leng}, return None.")
+            return None
+
+        if leng == 1:
+            logger.warning(f"Only one candidate, got {leng}, return it.")
+            return candidates
+        logger.info(f"Choose best {k} from {leng} candidates.")
+
+        rating_seq = await self.composite_score(
+            to_rate=[c.display() if isinstance(c, Display) else c for c in candidates], **kwargs
+        )
+        return [a[0] for a in sorted(zip(candidates, rating_seq, strict=True), key=lambda x: x[1], reverse=True)[:k]]  # pyright: ignore [reportReturnType]

fabricatio/capabilities/review.py

@@ -2,7 +2,6 @@
 
 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 Rating
 from fabricatio.config import configs
@@ -10,6 +9,7 @@ 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.rust_instances import TEMPLATE_MANAGER
 from fabricatio.utils import ok
 
 

fabricatio/capabilities/task.py

@@ -4,7 +4,7 @@ from types import CodeType
 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
@@ -13,6 +13,7 @@ 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(Propose):

fabricatio/config.py

@@ -229,9 +229,6 @@ 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."""
 
@@ -241,6 +238,17 @@ class TemplateConfig(BaseModel):
     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."""
+
+    rule_requirement_template: str = Field(default="rule_requirement")
+    """The name of the rule requirement template which will be used to generate a rule requirement."""
 class MagikaConfig(BaseModel):
     """Magika configuration class."""
 

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(WithBriefing, 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(WithBriefing, 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.
@@ -97,7 +103,8 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     A workflow manages the execution of multiple actions in sequence, passing
     a shared context between them and handling task lifecycle events.
     """
-    description:str =""
+
+    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))
@@ -111,10 +118,10 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     )
     """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)

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

@@ -5,18 +5,21 @@ from typing import List
 from fabricatio.models.generic import Display, ProposedAble
 
 
-class JudgeMent(ProposedAble,Display):
+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."""
 

fabricatio/models/extra/article_base.py

@@ -15,6 +15,7 @@ from fabricatio.models.generic import (
     PersistentAble,
     ProposedUpdateAble,
     ResolveUpdateConflict,
+    SequencePatch,
 )
 
 
@@ -29,7 +30,7 @@ class ReferringType(StrEnum):
 type RefKey = Tuple[str, Optional[str], Optional[str]]
 
 
-class ArticleRef(CensoredAble, Display, ProposedUpdateAble):
+class ArticleRef(CensoredAble, ProposedUpdateAble):
     """Reference to a specific chapter, section or subsection within the article. You SHALL not refer to an article component that is external and not present within our own article.
 
     Examples:
@@ -120,25 +121,7 @@ class ArticleMetaData(CensoredAble, Display):
     """Do not add any prefix or suffix to the title. should not contain special characters."""
 
 
-class Patch[T](ProposedUpdateAble, Display):
-    """Base class for patches."""
-
-    tweaked: List[T]
-    """Tweaked content list"""
-
-    def update_from_inner(self, other: Self) -> Self:
-        """Updates the current instance with the attributes of another instance."""
-        self.tweaked.clear()
-        self.tweaked.extend(other.tweaked)
-        return self
-
-    @classmethod
-    def default(cls) -> Self:
-        """Defaults to empty list."""
-        return cls(tweaked=[])
-
-
-class ArticleRefPatch(Patch[ArticleRef]):
+class ArticleRefSequencePatch(SequencePatch[ArticleRef]):
     """Patch for article refs."""
 
 

fabricatio/models/extra/article_main.py

@@ -8,14 +8,13 @@ from fabricatio.models.extra.article_base import (
     ArticleBase,
     ArticleOutlineBase,
     ChapterBase,
-    Patch,
     SectionBase,
     SubSectionBase,
 )
 from fabricatio.models.extra.article_outline import (
     ArticleOutline,
 )
-from fabricatio.models.generic import CensoredAble, Display, PersistentAble, WithRef
+from fabricatio.models.generic import CensoredAble, Display, PersistentAble, SequencePatch, WithRef
 from fabricatio.utils import ok
 
 
@@ -32,7 +31,7 @@ class Paragraph(CensoredAble):
     """The actual content of the paragraph, represented as a string."""
 
 
-class ArticleParagraphPatch(Patch[Paragraph]):
+class ArticleParagraphSequencePatch(SequencePatch[Paragraph]):
     """Patch for `Paragraph` list of `ArticleSubsection`."""
 
 

fabricatio/models/extra/patches.py

@@ -0,0 +1,20 @@
+"""A patch class for updating the description and name of a `WithBriefing` object, all fields within this instance will be directly copied onto the target model's field."""
+
+from typing import Optional, Type
+
+from fabricatio.models.extra.rule import RuleSet
+from fabricatio.models.generic import Patch, WithBriefing
+from pydantic import BaseModel
+
+
+class BriefingPatch[T: WithBriefing](Patch[T], WithBriefing):
+    """Patch class for updating the description and name of a `WithBriefing` object, all fields within this instance will be directly copied onto the target model's field."""
+
+
+class RuleSetBriefingPatch(BriefingPatch[RuleSet]):
+    """Patch class for updating the description and name of a `RuleSet` object, all fields within this instance will be directly copied onto the target model's field."""
+    language: str
+    @staticmethod
+    def ref_cls() -> Optional[Type[BaseModel]]:
+        """Get the reference class of the model."""
+        return RuleSet

fabricatio/models/extra/problem.py

@@ -1,14 +1,16 @@
 """A class representing a problem-solution pair identified during a review process."""
 
-from typing import List, Literal, Self
+from itertools import chain
+from typing import List, Literal, Optional, Self
 
-from fabricatio.models.generic import Display, ProposedAble, ProposedUpdateAble, WithBriefing
+from fabricatio.journal import logger
+from fabricatio.models.generic import SketchedAble, WithBriefing
 from fabricatio.utils import ask_edit
 from questionary import Choice, checkbox, text
 from rich import print as r_print
 
 
-class Problem(ProposedAble, WithBriefing, Display):
+class Problem(SketchedAble, WithBriefing):
     """Represents a problem identified during review."""
 
     description: str
@@ -27,11 +29,14 @@ class Problem(ProposedAble, WithBriefing, Display):
     """Recommended solution or action."""
 
 
-class Solution(ProposedAble, WithBriefing, Display):
+class Solution(SketchedAble, WithBriefing):
     """Represents a proposed solution to a problem."""
 
-    operation: str
-    """Description or identifier of the operation."""
+    description: str
+    """Description of the solution, including a detailed description of the execution steps, and the mechanics, principle or fact."""
+
+    execute_steps: List[str]
+    """A list of steps to execute to implement the solution, which is expected to be able to finally solve the corresponding problem."""
 
     feasibility: Literal["low", "medium", "high"]
     """Feasibility level of the solution."""
@@ -40,7 +45,7 @@ class Solution(ProposedAble, WithBriefing, Display):
     """Impact level of the solution."""
 
 
-class ProblemSolutions(ProposedUpdateAble):
+class ProblemSolutions(SketchedAble):
     """Represents a problem-solution pair identified during a review process."""
 
     problem: Problem
@@ -78,10 +83,26 @@ class ProblemSolutions(ProposedUpdateAble):
         self.solutions = [Solution.model_validate_strings(s) for s in string_seq]
         return self
 
+    def decided(self) -> bool:
+        """Check if the improvement is decided."""
+        return len(self.solutions) == 1
+
+    def final_solution(self) -> Optional[Solution]:
+        """Get the final solution."""
+        if not self.decided():
+            logger.error(
+                f"There is more than one solution for problem {self.problem.name}, please decide which solution is eventually adopted."
+            )
+            return None
+        return self.solutions[0]
+
 
-class Improvement(ProposedAble, Display):
+class Improvement(SketchedAble):
     """A class representing an improvement suggestion."""
 
+    focused_on: str
+    """The focused on topic of the improvement"""
+
     problem_solutions: List[ProblemSolutions]
     """Collection of problems identified during review along with their potential solutions."""
 
@@ -118,3 +139,15 @@ class Improvement(ProposedAble, Display):
             await to_exam.edit_solutions()
 
         return self
+
+    def decided(self) -> bool:
+        """Check if the improvement is decided."""
+        return all(ps.decided() for ps in self.problem_solutions)
+
+    @classmethod
+    def gather(cls, *improvements: Self) -> Self:
+        """Gather multiple improvements into a single instance."""
+        return cls(
+            focused_on="\n".join(imp.focused_on for imp in improvements),
+            problem_solutions=list(chain(*(imp.problem_solutions for imp in improvements))),
+        )

fabricatio/models/extra/rule.py

@@ -1,23 +1,40 @@
-"""A module containing classes related to rule sets and rules."""
+"""A module containing classes related to rule sets and rules.
+
+This module provides the `Rule` and `RuleSet` classes, which are used to define and manage
+individual rules and collections of rules, respectively. These classes are designed to
+facilitate the creation, organization, and application of rules in various contexts,
+ensuring clarity, consistency, and enforceability. The module supports detailed
+descriptions, examples, and metadata for each rule and rule set, making it suitable for
+complex rule management systems.
+"""
 
 from typing import List
 
-from fabricatio.models.generic import Described, Display, PersistentAble, ProposedAble, WithBriefing
+from fabricatio.models.generic import Language, PersistentAble, SketchedAble, WithBriefing
 
 
-class Rule(WithBriefing,ProposedAble,Display):
+class Rule(WithBriefing,Language, SketchedAble,PersistentAble):
     """Represents a rule or guideline for a specific topic."""
 
+
     violation_examples: List[str]
-    """Examples of violations of the rule."""
+    """A list of concrete examples demonstrating violations of this rule. Each example should
+    be a clear scenario or case that illustrates how the rule can be broken, including the
+    context, actions, and consequences of the violation. These examples should help in
+    understanding the boundaries of the rule."""
+
     compliance_examples: List[str]
-    """Examples of how to comply with the rule."""
+    """A list of concrete examples demonstrating proper compliance with this rule. Each example
+    should be a clear scenario or case that illustrates how to correctly follow the rule,
+    including the context, actions, and positive outcomes of compliance. These examples should
+    serve as practical guidance for implementing the rule correctly."""
 
 
-class RuleSet(ProposedAble, Display, PersistentAble, Described):
+class RuleSet( SketchedAble, PersistentAble, WithBriefing,Language):
     """Represents a collection of rules and guidelines for a particular topic."""
 
-    title: str
-    """The title of the rule set."""
     rules: List[Rule]
-    """The rules and guidelines contained in the rule set."""
+    """The collection of rules and guidelines contained in this rule set. Each rule should be
+    a well-defined, specific guideline that contributes to the overall purpose of the rule set.
+    The rules should be logically organized and consistent with each other, forming a coherent
+    framework for the topic or domain covered by the rule set."""