fabricatio 0.2.9.dev3__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.9.dev4__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/actions/article.py

@@ -105,7 +105,6 @@ class GenerateArticleProposal(Action, Propose):
         task_input: Optional[Task] = None,
         article_briefing: Optional[str] = None,
         article_briefing_path: Optional[str] = None,
-        langauge: Optional[str] = None,
         **_,
     ) -> Optional[ArticleProposal]:
         if article_briefing is None and article_briefing_path is None and task_input is None:
@@ -122,17 +121,14 @@ class GenerateArticleProposal(Action, Propose):
             )
         )
 
-        proposal = ok(
+        logger.info("Start generating the proposal.")
+        return ok(
             await self.propose(
                 ArticleProposal,
-                f"{briefing}\n\nWrite the value string using `{detect_language(briefing)}`",
+                f"{briefing}\n\nWrite the value string using `{detect_language(briefing)}` as written language.",
             ),
             "Could not generate the proposal.",
         ).update_ref(briefing)
-        if langauge:
-            proposal.language = langauge
-
-        return proposal
 
 
 class GenerateInitialOutline(Action, Propose):
@@ -149,7 +145,7 @@ class GenerateInitialOutline(Action, Propose):
         return ok(
             await self.propose(
                 ArticleOutline,
-                f"{(p := article_proposal.as_prompt())}\n\nNote that you should use `{detect_language(p)}` to write the `ArticleOutline`\n"
+                f"{(article_proposal.as_prompt())}\n\nNote that you should use `{article_proposal.language}` to write the `ArticleOutline`\n"
                 f"You Must make sure every chapter have sections, and every section have subsections.",
             ),
             "Could not generate the initial outline.",
@@ -318,7 +314,7 @@ class GenerateArticle(Action, Censor):
                 self.censor_obj_inplace(
                     subsec,
                     ruleset=ok(article_gen_ruleset or self.ruleset, "No ruleset provided"),
-                    reference=f"{article_outline.as_prompt()}\n# Error Need to be fixed\n{err}",
+                    reference=f"{article_outline.as_prompt()}\n# Error Need to be fixed\n{err}\nYou should use `{subsec.language}` to write the new `Subsection`.",
                 )
                 for _, _, subsec in article.iter_subsections()
                 if (err := subsec.introspect()) and logger.warning(f"Found Introspection Error:\n{err}") is None

fabricatio/actions/article_rag.py

@@ -29,6 +29,9 @@ class TweakArticleRAG(Action, RAG, Censor):
     ruleset: Optional[RuleSet] = None
     """The ruleset to be used for censoring the article."""
 
+    ref_limit: int = 30
+    """The limit of references to be retrieved"""
+
     async def _execute(
         self,
         article: Article,
@@ -88,11 +91,15 @@ class TweakArticleRAG(Action, RAG, Censor):
                 f"{subsec.display()}\n"
                 f"# Requirement\n"
                 f"Search related articles in the base to find reference candidates, "
-                f"prioritizing both original article language and English usage, which can return multiple candidates.",
+                f"provide queries in both `English` and `{subsec.language}` can get more accurate results.",
             )
         )
         await self.censor_obj_inplace(
             subsec,
             ruleset=ruleset,
-            reference=await self.aretrieve_compact(refind_q, final_limit=30),
+            reference=f"{await self.aretrieve_compact(refind_q, final_limit=self.ref_limit)}\n\n"
+            f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
+            f"You should Always use `{subsec.language}` as written language, "
+            f"which is the original language of the `{subsec.title}`. "
+            f"since rewrite a `{subsec.__class__.__name__}` in a different language is usually a bad choice",
         )

fabricatio/capabilities/check.py

@@ -8,7 +8,7 @@ from fabricatio.capabilities.advanced_judge import AdvancedJudge
 from fabricatio.capabilities.propose import Propose
 from fabricatio.config import configs
 from fabricatio.journal import logger
-from fabricatio.models.extra.patches import RuleSetBriefingPatch
+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
@@ -42,12 +42,17 @@ 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:
@@ -65,7 +70,7 @@ class Check(AdvancedJudge, Propose):
             return None
 
         ruleset_patch = await self.propose(
-            RuleSetBriefingPatch,
+            RuleSetMetadata,
             f"{ruleset_requirement}\n\nYou should use `{detect_language(ruleset_requirement)}`!",
             **override_kwargs(kwargs, default=None),
         )

fabricatio/capabilities/correct.py

@@ -57,7 +57,7 @@ class Correct(Rating, Propose):
                     self.decide_solution(
                         ps,
                         **fallback_kwargs(
-                            kwargs, topic=f"which solution is better to deal this problem {ps.problem.compact()}\n\n"
+                            kwargs, topic=f"which solution is better to deal this problem {ps.problem.description}\n\n"
                         ),
                     )
                     for ps in improvement.problem_solutions
@@ -167,13 +167,12 @@ class Correct(Rating, Propose):
             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:
-            logger.info(f"Fixing troubling obj {obj.__class__.__name__} when deal with problem: {ps.problem.name}")
+        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.name}",
-                )
+                logger.error(f"[{idx + 1}/{total}] Failed to fix problem `{ps.problem.name}`")
                 return None
             obj = fixed_obj
         return obj

fabricatio/capabilities/rating.py

@@ -5,19 +5,19 @@ from random import sample
 from typing import Dict, List, Optional, Set, Tuple, Union, Unpack, overload
 
 from more_itertools import flatten, windowed
-from pydantic import NonNegativeInt, PositiveInt
+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.rust_instances import TEMPLATE_MANAGER
-from fabricatio.utils import ok, override_kwargs
+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:
@@ -30,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:
@@ -42,45 +42,49 @@ class Rating(LLMUsage):
         Returns:
             Dict[str, float]: A dictionary with the ratings for each dimension.
         """
-
-        def _validator(response: str) -> Optional[Dict[str, float]] :
-            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(
@@ -112,7 +116,7 @@ class Rating(LLMUsage):
         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:
@@ -133,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]]]
@@ -244,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,
@@ -319,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))
 

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."""

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,
+    )

fabricatio/models/extra/advanced_judge.py

@@ -2,17 +2,17 @@
 
 from typing import List
 
-from fabricatio.models.generic import Display, ProposedAble
+from fabricatio.models.generic import SketchedAble
 
 
-class JudgeMent(ProposedAble, Display):
+class JudgeMent(SketchedAble):
     """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"""
+    """The issue to be judged, true for affirmation, false for denial."""
 
     deny_evidence: List[str]
     """List of clues supporting the denial."""

fabricatio/models/extra/article_base.py

@@ -17,7 +17,10 @@ from fabricatio.models.generic import (
     ResolveUpdateConflict,
     SequencePatch,
     SketchedAble,
+    Titled,
+    WordCount,
 )
+from pydantic import Field
 
 
 class ReferringType(StrEnum):
@@ -38,44 +41,44 @@ class ArticleRef(ProposedUpdateAble):
         - Referring to a chapter titled `Introduction`:
             Using Python
             ```python
-            ArticleRef(referred_chapter_title="Introduction")
+            ArticleRef(chap="Introduction")
             ```
             Using JSON
             ```json
-            {referred_chapter_title="Introduction"}
+            {chap="Introduction"}
             ```
         - Referring to a section titled `Background` under the `Introduction` chapter:
             Using Python
             ```python
-            ArticleRef(referred_chapter_title="Introduction", referred_section_title="Background")
+            ArticleRef(chap="Introduction", sec="Background")
             ```
             Using JSON
             ```json
-            {referred_chapter_title="Introduction", referred_section_title="Background"}
+            {chap="Introduction", sec="Background"}
             ```
         - Referring to a subsection titled `Related Work` under the `Background` section of the `Introduction` chapter:
             Using Python
             ```python
-            ArticleRef(referred_chapter_title="Introduction", referred_section_title="Background", referred_subsection_title="Related Work")
+            ArticleRef(chap="Introduction", sec="Background", subsec="Related Work")
             ```
             Using JSON
             ```json
-            {referred_chapter_title="Introduction", referred_section_title="Background", referred_subsection_title="Related Work"}
+            {chap="Introduction", sec="Background", subsec="Related Work"}
             ```
     """
 
-    referred_chapter_title: str
+    chap: str
     """`title` Field of the referenced chapter"""
-    referred_section_title: Optional[str] = None
+    sec: Optional[str] = None
     """`title` Field of the referenced section."""
-    referred_subsection_title: Optional[str] = None
+    subsec: Optional[str] = None
     """`title` Field of the referenced subsection."""
 
     def update_from_inner(self, other: Self) -> Self:
         """Updates the current instance with the attributes of another instance."""
-        self.referred_chapter_title = other.referred_chapter_title
-        self.referred_section_title = other.referred_section_title
-        self.referred_subsection_title = other.referred_subsection_title
+        self.chap = other.chap
+        self.sec = other.sec
+        self.subsec = other.subsec
         return self
 
     def deref(self, article: "ArticleBase") -> Optional["ArticleOutlineBase"]:
@@ -87,39 +90,41 @@ class ArticleRef(ProposedUpdateAble):
         Returns:
             ArticleMainBase | ArticleOutline | None: The dereferenced section or subsection, or None if not found.
         """
-        chap = next((chap for chap in article.chapters if chap.title == self.referred_chapter_title), None)
-        if self.referred_section_title is None or chap is None:
+        chap = next((chap for chap in article.chapters if chap.title == self.chap), None)
+        if self.sec is None or chap is None:
             return chap
-        sec = next((sec for sec in chap.sections if sec.title == self.referred_section_title), None)
-        if self.referred_subsection_title is None or sec is None:
+        sec = next((sec for sec in chap.sections if sec.title == self.sec), None)
+        if self.subsec is None or sec is None:
             return sec
-        return next((subsec for subsec in sec.subsections if subsec.title == self.referred_subsection_title), None)
+        return next((subsec for subsec in sec.subsections if subsec.title == self.subsec), None)
 
     @property
     def referring_type(self) -> ReferringType:
         """Determine the type of reference based on the presence of specific attributes."""
-        if self.referred_subsection_title is not None:
+        if self.subsec is not None:
             return ReferringType.SUBSECTION
-        if self.referred_section_title is not None:
+        if self.sec is not None:
             return ReferringType.SECTION
         return ReferringType.CHAPTER
 
 
-class ArticleMetaData(SketchedAble, Described, Language):
+class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
     """Metadata for an article component."""
 
-    support_to: List[ArticleRef]
-    """List of references to other component of this articles that this component supports."""
-    depend_on: List[ArticleRef]
-    """List of references to other component of this articles that this component depends on."""
+    description: str = Field(
+        alias="elaboration",
+        description=Described.model_fields["description"].description,
+    )
+
+    title: str = Field(alias="heading", description=Titled.model_fields["title"].description)
 
-    writing_aim: List[str]
+    aims: List[str]
     """List of writing aims of the research component in academic style."""
-    title: str
-    """Do not add any prefix or suffix to the title. should not contain special characters."""
 
-    expected_word_count: int
-    """Expected word count of this research component."""
+    support_to: List[ArticleRef]
+    """List of references to other future components in this article that this component supports to."""
+    depend_on: List[ArticleRef]
+    """List of references to other previous components in this article that this component depends on."""
 
 
 class ArticleRefSequencePatch(SequencePatch[ArticleRef]):
@@ -147,8 +152,8 @@ class ArticleOutlineBase(
         self.support_to.extend(other.support_to)
         self.depend_on.clear()
         self.depend_on.extend(other.depend_on)
-        self.writing_aim.clear()
-        self.writing_aim.extend(other.writing_aim)
+        self.aims.clear()
+        self.aims.extend(other.aims)
         self.description = other.description
         return self
 
@@ -272,22 +277,19 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
         return ""
 
 
-class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, Language, ABC):
+class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Described, Titled, Language, ABC):
     """Base class for article outlines."""
 
-    title: str
-    """Title of the academic paper."""
+    title: str = Field(alias="heading", description=Titled.model_fields["title"].description)
+    description: str = Field(alias="abstract")
+    """The abstract serves as a concise summary of an academic article, encapsulating its core purpose, methodologies, key results,
+    and conclusions while enabling readers to rapidly assess the relevance and significance of the study.
+    Functioning as the article's distilled essence, it succinctly articulates the research problem, objectives,
+    and scope, providing a roadmap for the full text while also facilitating database indexing, literature reviews,
+    and citation tracking through standardized metadata. Additionally, it acts as an accessibility gateway,
+    allowing scholars to gauge the study's contribution to existing knowledge, its methodological rigor,
+    and its broader implications without engaging with the entire manuscript, thereby optimizing scholarly communication efficiency."""
 
-    prospect: str
-    """Consolidated research statement with four pillars:
-    1. Problem Identification: Current limitations
-    2. Methodological Response: Technical approach
-    3. Empirical Validation: Evaluation strategy
-    4. Scholarly Impact: Field contributions
-    """
-
-    abstract: str
-    """The abstract is a concise summary of the academic paper's main findings."""
     chapters: List[T]
     """Chapters of the article. Contains at least one chapter. You can also add more as needed."""
 
@@ -415,14 +417,12 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, Language, ABC):
                 if not ref.deref(self):
                     summary += f"Invalid internal reference in `{component.__class__.__name__}` titled `{component.title}`, because the referred {ref.referring_type} is not exists within the article, see the original obj dump: {ref.model_dump()}\n"
 
-                    if ref.referred_chapter_title not in (chap_titles_set):
-                        summary += f"Chapter titled `{ref.referred_chapter_title}` is not any of {chap_titles_set}\n"
-                    if ref.referred_section_title and ref.referred_section_title not in (sec_titles_set):
-                        summary += f"Section Titled `{ref.referred_section_title}` is not any of {sec_titles_set}\n"
-                    if ref.referred_subsection_title and ref.referred_subsection_title not in (subsec_titles_set):
-                        summary += (
-                            f"Subsection Titled `{ref.referred_subsection_title}` is not any of {subsec_titles_set}"
-                        )
+                    if ref.chap not in (chap_titles_set):
+                        summary += f"Chapter titled `{ref.chap}` is not any of {chap_titles_set}\n"
+                    if ref.sec and ref.sec not in (sec_titles_set):
+                        summary += f"Section Titled `{ref.sec}` is not any of {sec_titles_set}\n"
+                    if ref.subsec and ref.subsec not in (subsec_titles_set):
+                        summary += f"Subsection Titled `{ref.subsec}` is not any of {subsec_titles_set}"
 
                 if summary:
                     return (
@@ -453,17 +453,15 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, Language, ABC):
                 r for r in chain(component.depend_on, component.support_to) if not r.deref(self) and r not in res_seq
             ):
                 res_seq.append(ref)
-                if ref.referred_chapter_title not in chap_titles_set:
-                    summary.append(
-                        f"Chapter titled `{ref.referred_chapter_title}` is not exist, since it is not any of {chap_titles_set}."
-                    )
-                if ref.referred_section_title and (ref.referred_section_title not in sec_titles_set):
+                if ref.chap not in chap_titles_set:
                     summary.append(
-                        f"Section Titled `{ref.referred_section_title}` is not exist, since it is not any of {sec_titles_set}"
+                        f"Chapter titled `{ref.chap}` is not exist, since it is not any of {chap_titles_set}."
                     )
-                if ref.referred_subsection_title and (ref.referred_subsection_title not in subsec_titles_set):
+                if ref.sec and (ref.sec not in sec_titles_set):
+                    summary.append(f"Section Titled `{ref.sec}` is not exist, since it is not any of {sec_titles_set}")
+                if ref.subsec and (ref.subsec not in subsec_titles_set):
                     summary.append(
-                        f"Subsection Titled `{ref.referred_subsection_title}` is not exist, since it is not any of {subsec_titles_set}"
+                        f"Subsection Titled `{ref.subsec}` is not exist, since it is not any of {subsec_titles_set}"
                     )
 
         return res_seq, "\n".join(summary)

fabricatio/models/extra/article_main.py

@@ -3,6 +3,7 @@
 from itertools import chain
 from typing import Dict, Generator, List, Self, Tuple, override
 
+from fabricatio.fs.readers import extract_sections
 from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
     ArticleBase,
@@ -14,26 +15,33 @@ from fabricatio.models.extra.article_base import (
 from fabricatio.models.extra.article_outline import (
     ArticleOutline,
 )
-from fabricatio.models.generic import PersistentAble, SequencePatch, SketchedAble, WithRef
-from fabricatio.rust import word_count
+from fabricatio.models.generic import Described, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
+from fabricatio.rust import detect_language, word_count
 from fabricatio.utils import ok
+from pydantic import Field
 
+PARAGRAPH_SEP = "// - - -"
 
-class Paragraph(SketchedAble):
+
+class Paragraph(SketchedAble, WordCount, Described):
     """Structured academic paragraph blueprint for controlled content generation."""
 
-    description: str
-    """Functional summary of the paragraph's role in document structure."""
+    description: str = Field(
+        alias="elaboration",
+        description=Described.model_fields["description"].description,
+    )
 
-    writing_aim: List[str]
+    aims: List[str]
     """Specific communicative objectives for this paragraph's content."""
 
-    expected_word_count: int
-    """Expected word count for the paragraph."""
-
     content: str
     """The actual content of the paragraph, represented as a string."""
 
+    @classmethod
+    def from_content(cls, content: str) -> Self:
+        """Create a Paragraph object from the given content."""
+        return cls(elaboration="", aims=[], expected_word_count=word_count(content), content=content)
+
 
 class ArticleParagraphSequencePatch(SequencePatch[Paragraph]):
     """Patch for `Paragraph` list of `ArticleSubsection`."""
@@ -57,12 +65,11 @@ class ArticleSubsection(SubSectionBase):
         """Introspects the subsection and returns a summary of its state."""
         summary = ""
         if len(self.paragraphs) == 0:
-            summary += f"`{self.__class__.__name__}` titled `{self.title}` have no paragraphs!\n"
-        if (
-            abs((wc := self.word_count) - self.expected_word_count) / self.expected_word_count
-            > self._max_word_count_deviation
-        ):
-            summary += f"`{self.__class__.__name__}` titled `{self.title}` have {wc} words, expected {self.expected_word_count} words!"
+            summary += f"`{self.__class__.__name__}` titled `{self.title}` have no paragraphs, You should add some!\n"
+        if abs((wc := self.word_count) - self.expected_word_count) / self.expected_word_count > self._max_word_count_deviation:
+            summary += (
+                f"`{self.__class__.__name__}` titled `{self.title}` have {wc} words, expected {self.word_count} words!"
+            )
 
         return summary
 
@@ -80,16 +87,64 @@ class ArticleSubsection(SubSectionBase):
         Returns:
             str: Typst code snippet for rendering.
         """
-        return f"=== {self.title}\n" + "\n\n".join(p.content for p in self.paragraphs)
+        return f"=== {self.title}\n" + f"\n{PARAGRAPH_SEP}\n".join(p.content for p in self.paragraphs)
+
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, language: str) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return cls(
+            heading=title,
+            elaboration="",
+            paragraphs=[Paragraph.from_content(p) for p in body.split(PARAGRAPH_SEP)],
+            expected_word_count=word_count(body),
+            language=language,
+            aims=[],
+            support_to=[],
+            depend_on=[],
+        )
 
 
 class ArticleSection(SectionBase[ArticleSubsection]):
     """Atomic argumentative unit with high-level specificity."""
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, language: str) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return cls(
+            subsections=[
+                ArticleSubsection.from_typst_code(*pack, language=language)
+                for pack in extract_sections(body, level=3, section_char="=")
+            ],
+            heading=title,
+            elaboration="",
+            expected_word_count=word_count(body),
+            language=language,
+            aims=[],
+            support_to=[],
+            depend_on=[],
+        )
+
 
 class ArticleChapter(ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str, language: str) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return cls(
+            sections=[
+                ArticleSection.from_typst_code(*pack, language=language)
+                for pack in extract_sections(body, level=2, section_char="=")
+            ],
+            heading=title,
+            elaboration="",
+            expected_word_count=word_count(body),
+            language=language,
+            aims=[],
+            support_to=[],
+            depend_on=[],
+        )
+
 
 class Article(
     SketchedAble,
@@ -126,31 +181,45 @@ class Article(
             Article: The generated article.
         """
         # Set the title from the outline
-        article = Article(**outline.model_dump(exclude={"chapters"}), chapters=[])
+        article = Article(**outline.model_dump(exclude={"chapters"}, by_alias=True), chapters=[])
 
         for chapter in outline.chapters:
             # Create a new chapter
             article_chapter = ArticleChapter(
                 sections=[],
-                **chapter.model_dump(exclude={"sections"}),
+                **chapter.model_dump(exclude={"sections"}, by_alias=True),
             )
             for section in chapter.sections:
                 # Create a new section
                 article_section = ArticleSection(
                     subsections=[],
-                    **section.model_dump(exclude={"subsections"}),
+                    **section.model_dump(exclude={"subsections"}, by_alias=True),
                 )
                 for subsection in section.subsections:
                     # Create a new subsection
                     article_subsection = ArticleSubsection(
                         paragraphs=[],
-                        **subsection.model_dump(),
+                        **subsection.model_dump(by_alias=True),
                     )
                     article_section.subsections.append(article_subsection)
                 article_chapter.sections.append(article_section)
             article.chapters.append(article_chapter)
         return article
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str) -> Self:
+        """Generates an article from the given Typst code."""
+        return cls(
+            language=(lang := detect_language(body)),
+            chapters=[
+                ArticleChapter.from_typst_code(*pack, language=lang)
+                for pack in extract_sections(body, level=1, section_char="=")
+            ],
+            heading=title,
+            expected_word_count=word_count(body),
+            abstract="",
+        )
+
     def gather_dependencies(self, article: ArticleOutlineBase) -> List[ArticleOutlineBase]:
         """Gathers dependencies for all sections and subsections in the article.
 

fabricatio/models/extra/article_proposal.py

@@ -2,21 +2,25 @@
 
 from typing import Dict, List
 
-from fabricatio.models.generic import AsPrompt, PersistentAble, SketchedAble, WithRef
-
-
-class ArticleProposal(SketchedAble, WithRef[str], AsPrompt, PersistentAble):
+from fabricatio.models.generic import (
+    AsPrompt,
+    Described,
+    Language,
+    PersistentAble,
+    SketchedAble,
+    Titled,
+    WithRef,
+    WordCount,
+)
+from pydantic import Field
+
+
+class ArticleProposal(SketchedAble, WithRef[str], AsPrompt, PersistentAble, WordCount, Described, Titled, Language):
     """Structured proposal for academic paper development with core research elements.
 
     Guides LLM in generating comprehensive research proposals with clearly defined components.
     """
 
-    language: str
-    """The language in which the article is written. This should align with the language specified in the article briefing."""
-
-    title: str
-    """The title of the academic paper, formatted in Title Case."""
-
     focused_problem: List[str]
     """A list of specific research problems or questions that the paper aims to address."""
 
@@ -38,12 +42,9 @@ class ArticleProposal(SketchedAble, WithRef[str], AsPrompt, PersistentAble):
     keywords: List[str]
     """A list of keywords that represent the main topics and focus areas of the research."""
 
-    abstract: str
+    description: str = Field(alias="abstract")
     """A concise summary of the research proposal, outlining the main points and objectives."""
 
-    expected_word_count: int
-    """The estimated word count of the final academic paper."""
-
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {
             "ArticleBriefing": self.referenced,

fabricatio/models/extra/patches.py

@@ -3,17 +3,17 @@
 from typing import Optional, Type
 
 from fabricatio.models.extra.rule import RuleSet
-from fabricatio.models.generic import Patch, WithBriefing
+from fabricatio.models.generic import Language, 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 BriefingMetadata[T: WithBriefing](Patch[T], WithBriefing):
+    """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."""
 
 
-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
+class RuleSetMetadata(BriefingMetadata[RuleSet], Language):
+    """A 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."""
+
     @staticmethod
     def ref_cls() -> Optional[Type[BaseModel]]:
         """Get the reference class of the model."""

fabricatio/models/generic.py

@@ -36,6 +36,7 @@ class Base(BaseModel):
     The `model_config` uses `use_attribute_docstrings=True` to ensure field descriptions are
     pulled from the attribute's docstring instead of the default Pydantic behavior.
     """
+
     model_config = ConfigDict(use_attribute_docstrings=True)
 
 
@@ -45,6 +46,7 @@ class Display(Base):
     Provides methods to generate both pretty-printed and compact JSON representations of the model.
     Used for debugging and logging purposes.
     """
+
     def display(self) -> str:
         """Generate pretty-printed JSON representation.
 
@@ -102,6 +104,20 @@ class Described(Base):
     this object's intent and application."""
 
 
+class Titled(Base):
+    """Class that includes a title attribute."""
+
+    title: str
+    """The title of this object, make it professional and concise.No prefixed heading number should be included."""
+
+
+class WordCount(Base):
+    """Class that includes a word count attribute."""
+
+    expected_word_count: int
+    """Expected word count of this research component."""
+
+
 class AsPrompt(Base):
     """Class that provides a method to generate a prompt from the model.
 
@@ -194,6 +210,7 @@ class PersistentAble(Base):
     Enables saving model instances to disk with timestamped filenames and loading from persisted files.
     Implements basic versioning through filename hashing and timestamping.
     """
+
     def persist(self, path: str | Path) -> Self:
         """Save model instance to disk with versioned filename.
 
@@ -208,7 +225,7 @@ class PersistentAble(Base):
             - Hash generated from JSON content ensures uniqueness
         """
         p = Path(path)
-        out = self.model_dump_json()
+        out = self.model_dump_json(indent=1)
 
         # Generate a timestamp in the format YYYYMMDD_HHMMSS
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -282,8 +299,7 @@ class Language(Base):
     """Class that provides a language attribute."""
 
     language: str
-    """The written language of this object, which should be aligned to the original requirement
-    For example if the requirement is in Chinese, the language should be set to `zh`, if the requirement is in English, the language should be set to `en` and etc."""
+    """The fullname of the written language of this object."""
 
 
 class ModelHash(Base):
@@ -670,6 +686,7 @@ class ScopedConfig(Base):
     Manages LLM, embedding, and vector database configurations with fallback logic.
     Allows configuration values to be overridden in a hierarchical manner.
     """
+
     llm_api_endpoint: Optional[HttpUrl] = None
     """The OpenAI API endpoint."""
 

fabricatio/models/usages.py

@@ -299,10 +299,11 @@ class LLMUsage(ScopedConfig):
             for lap in range(max_validations):
                 try:
                     if ((validated := validator(response := await self.aask(question=q, **kwargs))) is not None) or (
-                        co_extractor
+                        co_extractor is not None
+                        and logger.debug("Co-extraction is enabled.") is None
                         and (
                             validated := validator(
-                                await self.aask(
+                                response:=await self.aask(
                                     question=(
                                         TEMPLATE_MANAGER.render_template(
                                             configs.templates.co_validation_template,
@@ -319,12 +320,13 @@ class LLMUsage(ScopedConfig):
                         return validated
 
                 except RateLimitError as e:
-                    logger.warning(f"Rate limit error: {e}")
+                    logger.warning(f"Rate limit error:\n{e}")
                     continue
                 except Exception as e:  # noqa: BLE001
-                    logger.error(f"Error during validation: \n{e}")
+                    logger.error(f"Error during validation:\n{e}")
                     logger.debug(traceback.format_exc())
                     break
+                logger.error(f"Failed to validate the response at {lap}th attempt:\n{response}")
                 if not kwargs.get("no_cache"):
                     kwargs["no_cache"] = True
                     logger.debug("Closed the cache for the next attempt")

fabricatio/parser.py

@@ -48,10 +48,10 @@ class Capture(BaseModel):
             case "json" if configs.general.use_json_repair:
                 logger.debug("Applying json repair to text.")
                 if isinstance(text, str):
-                    return repair_json(text, ensure_ascii=False)
-                return [repair_json(item, ensure_ascii=False) for item in text]
+                    return repair_json(text, ensure_ascii=False)  # pyright: ignore [reportReturnType]
+                return [repair_json(item, ensure_ascii=False) for item in text]  # pyright: ignore [reportReturnType, reportGeneralTypeIssues]
             case _:
-                return text
+                return text  # pyright: ignore [reportReturnType]
 
     def capture(self, text: str) -> Tuple[str, ...] | str | None:
         """Capture the first occurrence of the pattern in the given text.
@@ -88,7 +88,7 @@ class Capture(BaseModel):
         if (cap := self.capture(text)) is None:
             return None
         try:
-            return convertor(cap)
+            return convertor(cap)  # pyright: ignore [reportArgumentType]
         except (ValueError, SyntaxError, ValidationError) as e:
             logger.error(f"Failed to convert text using {convertor.__name__} to convert.\nerror: {e}\n {cap}")
             return None
@@ -120,7 +120,7 @@ class Capture(BaseModel):
             judges.append(lambda output_obj: len(output_obj) == length)
 
         if (out := self.convert_with(text, deserializer)) and all(j(out) for j in judges):
-            return out
+            return out  # pyright: ignore [reportReturnType]
         return None
 
     @classmethod

fabricatio/rust.pyi

@@ -1,5 +1,4 @@
-"""
-Python interface definitions for Rust-based functionality.
+"""Python interface definitions for Rust-based functionality.
 
 This module provides type stubs and documentation for Rust-implemented utilities,
 including template rendering, cryptographic hashing, language detection, and
@@ -12,13 +11,11 @@ Key Features:
 - Text utilities: Word boundary splitting and word counting.
 """
 
-
 from pathlib import Path
 from typing import List, Optional
 
 from pydantic import JsonValue
 
-
 class TemplateManager:
     """Template rendering engine using Handlebars templates.
 
@@ -97,7 +94,6 @@ def blake3_hash(content: bytes) -> str:
 def detect_language(string: str) -> str:
     """Detect the language of a given string."""
 
-
 def split_word_bounds(string: str) -> List[str]:
     """Split the string into words based on word boundaries.
 
@@ -107,6 +103,7 @@ def split_word_bounds(string: str) -> List[str]:
     Returns:
         A list of words extracted from the string.
     """
+
 def word_count(string: str) -> int:
     """Count the number of words in the string.
 
@@ -117,8 +114,6 @@ def word_count(string: str) -> int:
         The number of words in the string.
     """
 
-
-
 class BibManager:
     """BibTeX bibliography manager for parsing and querying citation data."""
 

{fabricatio-0.2.9.dev3.dist-info → fabricatio-0.2.9.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.9.dev3
+Version: 0.2.9.dev4
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.9.dev3.dist-info → fabricatio-0.2.9.dev4.dist-info}/RECORD

@@ -1,25 +1,25 @@
-fabricatio-0.2.9.dev3.dist-info/METADATA,sha256=-YMYKshfG1_fnGcenw1aPHgSv1gz1RglZhmVhba4DFY,5151
-fabricatio-0.2.9.dev3.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
-fabricatio-0.2.9.dev3.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
+fabricatio-0.2.9.dev4.dist-info/METADATA,sha256=lhC_1huUN-HvdYRbIkko8yv7ZLD7SsXjWKxobL7c-sY,5151
+fabricatio-0.2.9.dev4.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
+fabricatio-0.2.9.dev4.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
 fabricatio/decorators.py,sha256=GrkclNTGT2bk7cjTyuca7mqSVlKwTcujcj3uBuZpT8s,7343
 fabricatio/core.py,sha256=MaEKZ6DDmbdScAY-7F1gwGA6fr7ADX6Mz5rNVi2msFA,6277
-fabricatio/models/generic.py,sha256=k2BiGvtNCdkH7BXGVH4f9cOKWGcUs9FVsY9sWTGEgHE,29163
+fabricatio/models/generic.py,sha256=TbL76hSM-cjCyQJhGtP-IHpC9OwsTcQ0RQQNlyvjddI,29345
 fabricatio/models/tool.py,sha256=VM3rMeDpUbeeFAKpsPfweJ2JGHf-w5f1voDnuhK99ew,12178
 fabricatio/models/role.py,sha256=iao4teYzY5QjfN1B2tEY5wbQq5afFz7jdhi6IziIong,2878
 fabricatio/models/kwargs_types.py,sha256=N-CqIDGzkcDSveY8NKUntkTJykst5dAhqjzDw5Zi54I,5479
 fabricatio/models/utils.py,sha256=x4ZSk5YfHjRuEz_zzcU-rI9nBV_idq9N9RFF6UT8FXg,4269
-fabricatio/models/extra/article_proposal.py,sha256=Y1F5UBnffKA8F8tYFGJP0zIPEANnWO-iWgVD1OzVpEw,1969
-fabricatio/models/extra/advanced_judge.py,sha256=iiiERQ12uOyloZAsSQpKoFX7LKVM5ci1zmtEgMoi6lw,967
-fabricatio/models/extra/article_main.py,sha256=Pix3tvFjAWLjqz5ns0N0TNDYTW4V8DxN-f4D614sqbI,8747
+fabricatio/models/extra/article_proposal.py,sha256=4G2qLkMxtK54G1ANgPW0G3w4Pahxgk2lhGPU5KMxuzw,1818
+fabricatio/models/extra/advanced_judge.py,sha256=LX84QK1WRbMlFiilCz1s6q1QoOh0tiI39bMTHEe8fGM,990
+fabricatio/models/extra/article_main.py,sha256=rthKqXbFa1GbzsxS02rezrQb2F2_JhQxkC8kt4W32iE,11368
 fabricatio/models/extra/problem.py,sha256=M4U9p1FcWFz2kZco_a6oULT96udh-PyuLs-KqAjBmV0,6490
 fabricatio/models/extra/article_essence.py,sha256=Fc1h05RFgKowHpHkdh-PNx3IxaUKLYdHVora-QM63WI,2726
 fabricatio/models/extra/article_outline.py,sha256=2vqMDhXwfRooHEe_cblkOj-4V96VsIAy68x22KBEQPQ,1387
 fabricatio/models/extra/__init__.py,sha256=0R9eZsCNu6OV-Xtf15H7FrqhfHTFBFf3fBrcd7ChsJ0,53
 fabricatio/models/extra/rule.py,sha256=UOqR6nuSpGJf0xVYLDM4wYR3x_ItfalCFlsaBE56LdM,2616
-fabricatio/models/extra/article_base.py,sha256=OFPWQTmyFd3z4n2jvC8jBpL14FR82xla75B1Tl-6Uf8,19862
-fabricatio/models/extra/patches.py,sha256=5Pw_xNiFsbcV-Cnh6hE3PLvwdrDptTxGY_j_AWTfnjo,969
+fabricatio/models/extra/article_base.py,sha256=GTr1M-5RlaWXJWjKMTihPWcwISxU5lHzKXFLjmzLsZM,19586
+fabricatio/models/extra/patches.py,sha256=_ghmnlvTZQq7UJyaH77mTZE9abjvxRJ2mgWHUbezUls,977
 fabricatio/models/adv_kwargs_types.py,sha256=NzTrhNvLGFns2qZJCCs4Xht5DKmPgX9nztOJFJjZWQ4,835
-fabricatio/models/usages.py,sha256=QJav_hEh6b7lq-ddoBYroHiOnbdceTPCgHKUOfXCL9g,31099
+fabricatio/models/usages.py,sha256=zim4NcEwbJVN9X5URwci6w3Qyj3jchJn3BtgtTtrr4U,31296
 fabricatio/models/events.py,sha256=UvOc6V3vfjKuvh7irDezJ8EGpsNo5yzLdq4xQexVonw,4063
 fabricatio/models/task.py,sha256=MygHTr3wC5MT3tdIU-seBhaRGq94aBAJFb464m5tm-g,10192
 fabricatio/models/action.py,sha256=b4Ml_RSKzEQ_Tr_aHbsHlNRMiwOdK_8Ui6-Lh8psnfU,9576
@@ -27,35 +27,35 @@ fabricatio/toolboxes/fs.py,sha256=OQMdeokYxSNVrCZJAweJ0cYiK4k2QuEiNdIbS5IHIV8,70
 fabricatio/toolboxes/__init__.py,sha256=dYm_Gd8XolSU_h4wnkA09dlaLDK146eeFz0CUgPZ8_c,380
 fabricatio/toolboxes/arithmetic.py,sha256=sSTPkKI6-mb278DwQKFO9jKyzc9kCx45xNH7V6bGBpE,1307
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fabricatio/fs/readers.py,sha256=5bLlpqcdhIwWfysh7gvfVv0PPPVAeDlTPGwNTio6j9M,1156
+fabricatio/fs/readers.py,sha256=56IR91ishQAvxfGPtEHlPn0DgkUd5x2QCrqm4pLHlqo,1819
 fabricatio/fs/curd.py,sha256=QqwnyLdVALNnerYGXf6a0irqoPSNE9_GJV9bJ33kbl0,4610
 fabricatio/fs/__init__.py,sha256=hTuYtzmvIGtbg7PTdoqLEQJ0E63hOzZltCIrLlDKaSE,559
 fabricatio/rust_instances.py,sha256=i5fIt6XkE8UwUU4JarmPt50AZs8aJW6efaypSLGLl0I,303
-fabricatio/config.py,sha256=NleUcBs5R1x63qZY0gQah9OVfCg9o2BXI4rC836p9LQ,17269
+fabricatio/config.py,sha256=Nes4-4YHKGJC6DDZEg6lEc7Z-EfhYxlszW92POMhVXo,17213
 fabricatio/utils.py,sha256=l852eYiDZZEy44SM29dWEoI1gDVzKu0odZU_fDEBArM,1656
 fabricatio/journal.py,sha256=Op0wC-JlZumnAc_aDmYM4ljnSNLoKEEMfcIRbCF69ow,455
-fabricatio/rust.pyi,sha256=8YH6SUlwpVEmWPz1ykhDzOdYrAoZyfLSPSh4ZIOp8Sg,6059
+fabricatio/rust.pyi,sha256=NBcID6R1gTtUfl7XKbPoEkvHqZ2YIUI2MSBrXMXz0Uk,6054
 fabricatio/__init__.py,sha256=OXoMMHJKHEB_vN97_34U4I5QpAKL9xnVQEVcBCvwBCg,986
 fabricatio/actions/output.py,sha256=GiZdrp5WYBo2YTKpbprIRpg0r8y4Bvg0Pg5FIs2vFJU,6340
-fabricatio/actions/article_rag.py,sha256=8N1vEAyX8tb2O5AOGA4zTbRjDlZnAF7Y4QavBa-B9vE,4195
+fabricatio/actions/article_rag.py,sha256=xYmRAXPrG8rIBiXUqMQOyjEVofx845S7t7EklJpbA5I,4630
 fabricatio/actions/rag.py,sha256=0jkk-weJN6HyXK18hMP-U24kL-HsurVTEFx4LST9qZE,2663
 fabricatio/actions/__init__.py,sha256=ZMa1LeM5BNeqp-J-D32W-f5bD53-kdXGyt0zuueJofM,47
-fabricatio/actions/article.py,sha256=wfa0EJRATc8JQ-pQWlXRDjFWg7v07unnOnQTXXmSGNo,12332
+fabricatio/actions/article.py,sha256=qzaTkxmjCcfGcRCNxVMzJ-EGVPfsfnDQ9xSV7VpuL4k,12345
 fabricatio/actions/rules.py,sha256=AtYqkPgErIiDUE3L4RDQk3IeIq2PhEQADAX3G3ko-ro,2785
 fabricatio/workflows/articles.py,sha256=ZDV5nqUKRo1GOuuKWeSV7ZI32FYZU7WiTrD4YDuCeEo,945
 fabricatio/workflows/rag.py,sha256=uOZXprD479fUhLA6sYvEM8RWcVcUZXXtP0xRbTMPdHE,509
 fabricatio/workflows/__init__.py,sha256=Lq9pFo2cudwFCrQUUNgSTr1CoU0J1Nw-HNEQN7cHLp8,50
-fabricatio/parser.py,sha256=AD9vgy-MljB8o3kH89RfwUyD5V296nrGnAe5u1nE00M,6165
+fabricatio/parser.py,sha256=mAXrvB3_bk6Cc1tDd11sq_XpsKuTcvypVVR3wFAZuLI,6382
 fabricatio/capabilities/censor.py,sha256=j6vyjKpR1CfLzC-XrOZSZePjJz3jsoM104gqqsWwi1Q,4615
 fabricatio/capabilities/advanced_judge.py,sha256=bvb8fYoiKoGlBwMZVMflVE9R2MoS1VtmZAo65jMJFew,683
-fabricatio/capabilities/check.py,sha256=b5SA7_y-n1PeTVpco69uJIxJeP3PxuE2K4gSI4WCUPQ,8180
-fabricatio/capabilities/correct.py,sha256=Gjs1BKBqP93j5C3lveykfc-lMvYG7yAYRZVH3gipgfY,10199
+fabricatio/capabilities/check.py,sha256=SOnXGRWMbQg5zdqAPgklyavvCifhvw0v4i67QGCnwpY,8308
+fabricatio/capabilities/correct.py,sha256=Et3Ud-oLZlwTVSy2XyT5UX2shT_OJ9j4HWP9b5Hntvk,10192
 fabricatio/capabilities/rag.py,sha256=It5uWwqbrX64MfQ3FbSvmgcpECAo8XWkLhtRSdTb0ME,17300
 fabricatio/capabilities/__init__.py,sha256=skaJ43CqAQaZMH-mCRzF4Fps3x99P2SwJ8vSM9pInX8,56
-fabricatio/capabilities/rating.py,sha256=qugLs9bKR10LBEnlW4X-FH_knVEsWUj0kzI6AwRgvpo,16655
+fabricatio/capabilities/rating.py,sha256=6kKQLaSA4pZF50fsukeUJV995hS_4jenEfCsSLwjidg,17245
 fabricatio/capabilities/review.py,sha256=EPL8IlxSKO0XStBkXdW7FJMbPztDQMv9w7tHgu6r3PM,4948
 fabricatio/capabilities/propose.py,sha256=vOJvmmnMBHUQB6N1AmZNFw42jf7Bl2mBRNlBK15TpNI,1942
 fabricatio/capabilities/task.py,sha256=gg1xcNlvHy7voR1GXiVDpKW16IvFofLInMlXgkhzBiQ,4304
-fabricatio/rust.cpython-312-x86_64-linux-gnu.so,sha256=zBLLbD9U7_jdOdsTcuN5ndxztWWF50k3unlI3PmIW5s,2259608
-fabricatio-0.2.9.dev3.data/scripts/tdown,sha256=zld9LfTDv-oL3cnxHkqRnI-5jG1r6woHRyNleB3g3GQ,4587928
-fabricatio-0.2.9.dev3.dist-info/RECORD,,
+fabricatio/rust.cpython-312-x86_64-linux-gnu.so,sha256=4RuvwA9hIlrKqb0RAEVA6yuLrjYQ9hZGZRPFIHCprT8,2261576
+fabricatio-0.2.9.dev4.data/scripts/tdown,sha256=tr6RMP9zOjtAtEuTvQq7fk64mpNMdyU7UGXpRJpTM3s,4603104
+fabricatio-0.2.9.dev4.dist-info/RECORD,,