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

fabricatio/capabilities/censor.py

@@ -8,6 +8,8 @@ from typing import Optional, Unpack
 
 from fabricatio.capabilities.check import Check
 from fabricatio.capabilities.correct import Correct
+from fabricatio.journal import logger
+from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.generic import ProposedUpdateAble, SketchedAble
 from fabricatio.models.kwargs_types import ReferencedKwargs
@@ -19,6 +21,7 @@ class Censor(Correct, Check):
 
     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.
+
     """
 
     async def censor_obj[M: SketchedAble](
@@ -39,8 +42,12 @@ class Censor(Correct, Check):
         """
         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)
+            return None
+        if not imp:
+            logger.info(f"No improvement found for `{obj.__class__.__name__}`.")
+            return obj
+        logger.info(f'Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}')
+        return await self.correct_obj(obj, Improvement.gather(*imp), **kwargs)
 
     async def censor_string(
         self, input_text: str, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[str]]
@@ -60,8 +67,13 @@ class Censor(Correct, Check):
         """
         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)
+            logger.warning(f"Censor failed for string:\n{input_text}")
+            return None
+        if not imp:
+            logger.info("No improvement found for string.")
+            return input_text
+        logger.info(f'Generated {len(imp)} improvement(s) for string.')
+        return await self.correct_string(input_text, Improvement.gather(*imp), **kwargs)
 
     async def censor_obj_inplace[M: ProposedUpdateAble](
         self, obj: M, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[M]]
@@ -83,5 +95,10 @@ class Censor(Correct, Check):
         """
         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)
+            logger.warning(f"Censor failed for `{obj.__class__.__name__}`")
+            return None
+        if not imp:
+            logger.info(f"No improvement found for `{obj.__class__.__name__}`.")
+            return obj
+        logger.info(f'Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}')
+        return await self.correct_obj_inplace(obj, improvement=Improvement.gather(*imp), **kwargs)

fabricatio/capabilities/check.py

@@ -1,16 +1,19 @@
 """A class that provides the capability to check strings and objects against rules and guidelines."""
 
-from typing import Optional, Unpack
+from asyncio import gather
+from typing import List, 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.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 detect_language
 from fabricatio.utils import override_kwargs
 
 
@@ -39,32 +42,43 @@ class Check(AdvancedJudge, Propose):
             - 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),
+        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_count > 1
+            else [ruleset_requirement]
         )
 
         if rule_reqs is None:
             return None
 
-        rules = await self.propose(Rule, rule_reqs, **kwargs)
+        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
 
         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",
+            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_patch.apply(RuleSet(rules=rules, name="", description=""))
+        return RuleSet(rules=rules, **ruleset_patch.as_kwargs())
 
     async def check_string_against_rule(
         self,
@@ -90,14 +104,16 @@ class Check(AdvancedJudge, Propose):
             - 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?",
+            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(
                     configs.templates.check_string_template,
-                    {"to_check": input_text, "rule": rule, "judge": judge.display(), "reference": reference},
+                    {"to_check": input_text, "rule": rule.display(), "judge": judge.display(), "reference": reference},
                 ),
                 **kwargs,
             )
@@ -141,7 +157,7 @@ class Check(AdvancedJudge, Propose):
         ruleset: RuleSet,
         reference: str = "",
         **kwargs: Unpack[ValidateKwargs[Improvement]],
-    ) -> Optional[Improvement]:
+    ) -> Optional[List[Improvement]]:
         """Validate text against full ruleset.
 
         Args:
@@ -158,12 +174,13 @@ class Check(AdvancedJudge, Propose):
             - 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
+        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,
@@ -171,7 +188,7 @@ class Check(AdvancedJudge, Propose):
         ruleset: RuleSet,
         reference: str = "",
         **kwargs: Unpack[ValidateKwargs[Improvement]],
-    ) -> Optional[Improvement]:
+    ) -> Optional[List[Improvement]]:
         """Validate object against full ruleset.
 
         Args:
@@ -188,7 +205,9 @@ class Check(AdvancedJudge, Propose):
             - 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
+        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,8 +1,8 @@
 """A module containing the Correct capability for reviewing, validating, and improving objects."""
 
+from asyncio import gather
 from typing import Optional, Type, Unpack, cast
 
-from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
 from fabricatio.capabilities.rating import Rating
 from fabricatio.config import configs
@@ -14,7 +14,8 @@ from fabricatio.models.kwargs_types import (
     BestKwargs,
     ValidateKwargs,
 )
-from fabricatio.utils import ok, override_kwargs
+from fabricatio.rust_instances import TEMPLATE_MANAGER
+from fabricatio.utils import fallback_kwargs, ok, override_kwargs
 
 
 class Correct(Rating, Propose):
@@ -33,8 +34,9 @@ class Correct(Rating, Propose):
             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}")
+            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
 
@@ -48,11 +50,25 @@ class Correct(Rating, Propose):
         Returns:
             Improvement: The improvement with the best solutions selected for each problem solution.
         """
-        if (leng := len(improvement.problem_solutions)) == 0:
+        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}")
-        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](
@@ -78,11 +94,11 @@ class Correct(Rating, Propose):
             TEMPLATE_MANAGER.render_template(
                 configs.templates.fix_troubled_obj_template,
                 {
-                    "problem": problem_solutions.problem,
+                    "problem": problem_solutions.problem.display(),
                     "solution": ok(
                         problem_solutions.final_solution(),
-                        f"No solution found for problem: {problem_solutions.problem}",
-                    ),
+                        f"{len(problem_solutions.solutions)} solution Found for `{problem_solutions.problem.name}`.",
+                    ).display(),
                     "reference": reference,
                 },
             ),
@@ -111,11 +127,11 @@ class Correct(Rating, Propose):
             TEMPLATE_MANAGER.render_template(
                 configs.templates.fix_troubled_string_template,
                 {
-                    "problem": problem_solutions.problem,
+                    "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,
                 },
@@ -148,14 +164,15 @@ class Correct(Rating, Propose):
             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))
 
-        for ps in improvement.problem_solutions:
+        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"Failed to fix troubling obj {obj.__class__.__name__} when deal with problem: {ps.problem}",
-                )
+                logger.error(f"[{idx + 1}/{total}] Failed to fix problem `{ps.problem.name}`")
                 return None
             obj = fixed_obj
         return obj
@@ -178,6 +195,8 @@ class Correct(Rating, Propose):
             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:

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)

fabricatio/capabilities/rating.py

@@ -4,19 +4,20 @@ 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 Field, NonNegativeInt, PositiveInt, create_model
+
+from fabricatio.capabilities.propose import Propose
 from fabricatio.config import configs
 from fabricatio.journal import logger
-from fabricatio.models.generic import Display
+from fabricatio.models.generic import Display, ProposedAble
 from fabricatio.models.kwargs_types import CompositeScoreKwargs, ValidateKwargs
-from fabricatio.models.usages import LLMUsage
 from fabricatio.parser import JsonCapture
-from fabricatio.utils import ok, override_kwargs
-from more_itertools import flatten, windowed
-from pydantic import NonNegativeInt, PositiveInt
+from fabricatio.rust_instances import TEMPLATE_MANAGER
+from fabricatio.utils import fallback_kwargs, ok, override_kwargs
 
 
-class Rating(LLMUsage):
+class Rating(Propose):
     """A class that provides functionality to rate tasks based on a rating manual and score range.
 
     References:
@@ -29,7 +30,7 @@ class Rating(LLMUsage):
         rating_manual: Dict[str, str],
         score_range: Tuple[float, float],
         **kwargs: Unpack[ValidateKwargs[Dict[str, float]]],
-    ) -> Optional[Dict[str, float] | List[Dict[str, float]]]:
+    ) -> Dict[str, float] | List[Dict[str, float]] | List[Optional[Dict[str, float]]] | None:
         """Rate a given string based on a rating manual and score range.
 
         Args:
@@ -41,45 +42,49 @@ class Rating(LLMUsage):
         Returns:
             Dict[str, float]: A dictionary with the ratings for each dimension.
         """
-
-        def _validator(response: str) -> Dict[str, float] | None:
-            if (
-                (json_data := JsonCapture.validate_with(response, dict, str))
-                and json_data.keys() == rating_manual.keys()
-                and all(score_range[0] <= v <= score_range[1] for v in json_data.values())
-            ):
-                return json_data
-            return None
-
-        logger.info(f"Rating for {to_rate}")
-        return await self.aask_validate(
-            question=(
-                TEMPLATE_MANAGER.render_template(
-                    configs.templates.rate_fine_grind_template,
-                    {
-                        "to_rate": to_rate,
-                        "min_score": score_range[0],
-                        "max_score": score_range[1],
-                        "rating_manual": rating_manual,
-                    },
+        min_score, max_score = score_range
+        tip = (max_score - min_score) / 9
+
+        model = create_model(  # pyright: ignore [reportCallIssue]
+            "RatingResult",
+            __base__=ProposedAble,
+            __doc__=f"The rating result contains the scores against each criterion, with min_score={min_score} and max_score={max_score}.",
+            **{  # pyright: ignore [reportArgumentType]
+                criterion: (
+                    float,
+                    Field(
+                        ge=min_score,
+                        le=max_score,
+                        description=desc,
+                        examples=[round(min_score + tip * i, 2) for i in range(10)],
+                    ),
                 )
+                for criterion, desc in rating_manual.items()
+            },
+        )
+
+        res = await self.propose(
+            model,
+            TEMPLATE_MANAGER.render_template(
+                configs.templates.rate_fine_grind_template,
+                {"to_rate": to_rate, "min_score": min_score, "max_score": max_score},
             )
             if isinstance(to_rate, str)
             else [
                 TEMPLATE_MANAGER.render_template(
                     configs.templates.rate_fine_grind_template,
-                    {
-                        "to_rate": item,
-                        "min_score": score_range[0],
-                        "max_score": score_range[1],
-                        "rating_manual": rating_manual,
-                    },
+                    {"to_rate": t, "min_score": min_score, "max_score": max_score},
                 )
-                for item in to_rate
+                for t in to_rate
             ],
-            validator=_validator,
-            **kwargs,
+            **override_kwargs(kwargs, default=None),
         )
+        default = kwargs.get("default")
+        if isinstance(res, list):
+            return [r.model_dump() if r else default for r in res]
+        if res is None:
+            return default
+        return res.model_dump()
 
     @overload
     async def rate(
@@ -87,7 +92,7 @@ class Rating(LLMUsage):
         to_rate: str,
         topic: str,
         criteria: Set[str],
-        manual: Optional[Dict[str, str]],
+        manual: Optional[Dict[str, str]] = None,
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
     ) -> Dict[str, float]: ...
@@ -98,7 +103,7 @@ class Rating(LLMUsage):
         to_rate: List[str],
         topic: str,
         criteria: Set[str],
-        manual: Optional[Dict[str, str]],
+        manual: Optional[Dict[str, str]] = None,
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
     ) -> List[Dict[str, float]]: ...
@@ -108,10 +113,10 @@ class Rating(LLMUsage):
         to_rate: Union[str, List[str]],
         topic: str,
         criteria: Set[str],
-        manual: Optional[Dict[str, str]],
+        manual: Optional[Dict[str, str]] = None,
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
-    ) -> Optional[Dict[str, float] | List[Dict[str, float]]]:
+    ) -> Dict[str, float] | List[Dict[str, float]] | List[Optional[Dict[str, float]]] | None:
         """Rate a given string or a sequence of strings based on a topic, criteria, and score range.
 
         Args:
@@ -132,7 +137,7 @@ class Rating(LLMUsage):
             or dict(zip(criteria, criteria, strict=True))
         )
 
-        return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
+        return await self.rate_fine_grind(to_rate, manual, score_range, **fallback_kwargs(kwargs, co_extractor={}))
 
     async def draft_rating_manual(
         self, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
@@ -169,7 +174,7 @@ class Rating(LLMUsage):
                     configs.templates.draft_rating_manual_template,
                     {
                         "topic": topic,
-                        "criteria": criteria,
+                        "criteria": list(criteria),
                     },
                 )
             ),
@@ -243,7 +248,7 @@ class Rating(LLMUsage):
 
         # extract reasons from the comparison of ordered pairs of extracted from examples
         reasons = flatten(
-            await self.aask_validate(
+            await self.aask_validate(  # pyright: ignore [reportArgumentType]
                 question=[
                     TEMPLATE_MANAGER.render_template(
                         configs.templates.extract_reasons_from_examples_template,
@@ -318,9 +323,11 @@ class Rating(LLMUsage):
             validator=lambda resp: JsonCapture.validate_with(resp, target_type=float),
             **kwargs,
         )
+        if not all(relative_weights):
+            raise ValueError(f"found illegal weight: {relative_weights}")
         weights = [1.0]
         for rw in relative_weights:
-            weights.append(weights[-1] * rw)
+            weights.append(weights[-1] * rw)  # pyright: ignore [reportOperatorIssue]
         total = sum(weights)
         return dict(zip(criteria_seq, [w / total for w in weights], strict=True))
 
@@ -359,14 +366,14 @@ class Rating(LLMUsage):
         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]: ...
+    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]
+        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]
+        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.
 

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

@@ -44,7 +44,7 @@ class LLMConfig(BaseModel):
         top_p (NonNegativeFloat): The top p of the LLM model. Controls diversity via nucleus sampling. Set to 0.35 as per request.
         generation_count (PositiveInt): The number of generations to generate. Default is 1.
         stream (bool): Whether to stream the LLM model's response. Default is False.
-        max_tokens (PositiveInt): The maximum number of tokens to generate. Set to 8192 as per request.
+        max_tokens (PositiveInt): The maximum number of tokens to generate.
     """
 
     model_config = ConfigDict(use_attribute_docstrings=True)
@@ -79,7 +79,7 @@ class LLMConfig(BaseModel):
     """Whether to stream the LLM model's response. Default is False."""
 
     max_tokens: Optional[PositiveInt] = Field(default=None)
-    """The maximum number of tokens to generate. Set to 8192 as per request."""
+    """The maximum number of tokens to generate."""
 
     rpm: Optional[PositiveInt] = Field(default=100)
     """The rate limit of the LLM model in requests per minute. None means not checked."""
@@ -247,6 +247,8 @@ class TemplateConfig(BaseModel):
     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."""
 
@@ -301,7 +303,7 @@ class CacheConfig(BaseModel):
 
     model_config = ConfigDict(use_attribute_docstrings=True)
 
-    type: Optional[LiteLLMCacheType] = None
+    type: LiteLLMCacheType = LiteLLMCacheType.LOCAL
     """The type of cache to use. If None, the default cache type will be used."""
     params: CacheKwargs = Field(default_factory=CacheKwargs)
     """The parameters for the cache. If type is None, the default parameters will be used."""

fabricatio/fs/readers.py

@@ -1,9 +1,10 @@
 """Filesystem readers for Fabricatio."""
 
 from pathlib import Path
-from typing import Dict
+from typing import Dict, List, Tuple
 
 import orjson
+import regex
 from magika import Magika
 
 from fabricatio.config import configs
@@ -44,3 +45,21 @@ def safe_json_read(path: Path | str) -> Dict:
     except (orjson.JSONDecodeError, IsADirectoryError, FileNotFoundError) as e:
         logger.error(f"Failed to read file {path}: {e!s}")
         return {}
+
+
+def extract_sections(string: str, level: int, section_char: str = "#") -> List[Tuple[str, str]]:
+    """Extract sections from markdown-style text by header level.
+
+    Args:
+        string (str): Input text to parse
+        level (int): Header level (e.g., 1 for '#', 2 for '##')
+        section_char (str, optional): The character used for headers (default: '#')
+
+    Returns:
+        List[Tuple[str, str]]: List of (header_text, section_content) tuples
+    """
+    return regex.findall(
+        r"^%s{%d}\s+(.+?)\n((?:(?!^%s{%d}\s).|\n)*)" % (section_char, level, section_char, level),
+        string,
+        regex.MULTILINE,
+    )