fabricatio 0.2.9.dev3__cp312-cp312-win_amd64.whl → 0.2.9.dev4__cp312-cp312-win_amd64.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,52 +1,52 @@
-fabricatio-0.2.9.dev3.dist-info/METADATA,sha256=i0UO11MDd1705wklU-72nOOidzq5y481MX-mVs29zyc,5288
-fabricatio-0.2.9.dev3.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
-fabricatio-0.2.9.dev3.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
-fabricatio/actions/article.py,sha256=tX3928xR4Lsbt7cH8gNwuTuluQJkAF-6FiKRlVIaDR4,12660
-fabricatio/actions/article_rag.py,sha256=5xYj_U5Q4jKMqiBohM5WoTT5MCA8EtF4silkLrwrtME,4293
+fabricatio-0.2.9.dev4.dist-info/METADATA,sha256=qo6WjSrz5Br7ypVenUufk1zhMg9yW_Qzt_hoLuOPFKo,5288
+fabricatio-0.2.9.dev4.dist-info/WHEEL,sha256=jABKVkLC9kJr8mi_er5jOqpiQUjARSLXDUIIxDqsS50,96
+fabricatio-0.2.9.dev4.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio/actions/article.py,sha256=uwRXKCzTp5C-vwIMuCJOsTwCU_F2uJ3cVNKS74AABbo,12669
+fabricatio/actions/article_rag.py,sha256=itGH-VCKTVFm7hrYIOOT4FyFXP8CbL042kpYNI9a2BE,4735
 fabricatio/actions/output.py,sha256=gkC2u_VpMJ6jOnbyRAJN24UVK7iDAMzhItYukaW8Spk,6498
 fabricatio/actions/rag.py,sha256=5nSih3YUkdt1uU02hSAMW6sADq9mkMOR1wDv7zIrIGQ,2737
 fabricatio/actions/rules.py,sha256=SNvAvQx4xUare16Za_dEpYlYI_PJNnbiO-E0XDa5JT4,2857
 fabricatio/actions/__init__.py,sha256=wVENCFtpVb1rLFxoOFJt9-8smLWXuJV7IwA8P3EfFz4,48
 fabricatio/capabilities/advanced_judge.py,sha256=selB0Gwf1F4gGJlwBiRo6gI4KOUROgh3WnzO3mZFEls,706
 fabricatio/capabilities/censor.py,sha256=bBT5qy-kp7fh8g4Lz3labSwxwJ60gGd_vrkc6k1cZ1U,4719
-fabricatio/capabilities/check.py,sha256=OVsI7V5bRnkzzsaYqsrvf6DQqPo4N_L5xYuku-7LqYc,8387
-fabricatio/capabilities/correct.py,sha256=jzVDG1X0DNgoyw3MQt2eI3J0OB6w2JtryuuxzSGl8EU,10428
+fabricatio/capabilities/check.py,sha256=q12h9mQyGGjWiJp4r7JgYWeuWzj0fT3DxtL7s4n-0pY,8520
+fabricatio/capabilities/correct.py,sha256=W_cInqlciNEhyMK0YI53jk4EvW9uAdge90IO9OElUmA,10420
 fabricatio/capabilities/propose.py,sha256=hkBeSlmcTdfYWT-ph6nlbtHXBozi_JXqXlWcnBy3W78,2007
 fabricatio/capabilities/rag.py,sha256=8TTJSV2Tz0naXyOQ5c_RQ4h9ZxyOOSE7BvyWxKkQMU0,17722
-fabricatio/capabilities/rating.py,sha256=I3bQ_t5HeNNlfPGc687J286BiHPrHvnAlC7LQbVw7Yo,17049
+fabricatio/capabilities/rating.py,sha256=Wt_H5fA1H4XuZGIMI8pr0cp_6jnXJABlo8lfU_4Fp5A,17645
 fabricatio/capabilities/review.py,sha256=-EMZe0ADFPT6fPGmra16UPjJC1M3rAs6dPFdTZ88Fgg,5060
 fabricatio/capabilities/task.py,sha256=JahC61X233UIPsjovxJgc_yqj_BjWZJBCzJZq11M2Xk,4417
 fabricatio/capabilities/__init__.py,sha256=v1cHRHIJ2gxyqMLNCs6ERVcCakSasZNYzmMI4lqAcls,57
-fabricatio/config.py,sha256=fJHPY3LXSZWpEF17rAkY-IKeuB7oFlQrkRBIsModnlI,17687
+fabricatio/config.py,sha256=gqhdKxoj4S0EmQKprAEWUARn7yJg-w5UJ7d7GPlyttw,17631
 fabricatio/core.py,sha256=VQ_JKgUGIy2gZ8xsTBZCdr_IP7wC5aPg0_bsOmjQ588,6458
 fabricatio/decorators.py,sha256=C0Gi7wcXC-0sWITqsSv3JdBGcgVJOlRvOt0FfO0aUsA,7554
 fabricatio/fs/curd.py,sha256=p8y0LGKgVDk-CWOlm37E6wg7RK6RCD6denKo-VsW28c,4763
-fabricatio/fs/readers.py,sha256=EZKN_AZdrp8DggJECP53QHw3uHeSDf-AwCAA_V7fNKU,1202
+fabricatio/fs/readers.py,sha256=M5kojKWsJQMQpE4CBbYvas0JKmPaiaYSfWmiqJx1SP4,1884
 fabricatio/fs/__init__.py,sha256=PCf0s_9KDjVfNw7AfPoJzGt3jMq4gJOfbcT4pb0D0ZY,588
 fabricatio/journal.py,sha256=stnEP88aUBA_GmU9gfTF2EZI8FS2OyMLGaMSTgK4QgA,476
 fabricatio/models/action.py,sha256=Kfa-zojgHQ1vPoC2lQp-thTTp0oySKn7k6I4ea6iYTs,9837
 fabricatio/models/adv_kwargs_types.py,sha256=dcYMLn6xcnWLZTLTBdtpgUZWi-VBeub721GzHRZFT1g,860
 fabricatio/models/events.py,sha256=QvlnS8FEELg6KNabcJMeh2GV_y0ZBzKOPphcteKYWYU,4183
-fabricatio/models/extra/advanced_judge.py,sha256=mi3KiB8FUuSYICzXPXKwVhCyRE1GL3gHLkwuc-4mh3c,999
-fabricatio/models/extra/article_base.py,sha256=a0ex3cttfoUtYic2EODzrN8cDFpH3eILUbUcLGrb_a8,20353
+fabricatio/models/extra/advanced_judge.py,sha256=x2FxicxqpN1eKD7PnL7--wYvxZsWnueAlCyHodRuFrU,1022
+fabricatio/models/extra/article_base.py,sha256=WWfa8LJVjrs_yJGBCI81KF5VtW62rq_IcdFvBqZ2nq0,20075
 fabricatio/models/extra/article_essence.py,sha256=xd6j-PDqjhrMjgUmyfk6HqkyMLu-sS9feUo0sZ3QABY,2825
-fabricatio/models/extra/article_main.py,sha256=sS8Vnnq6U6tFycDZYZ6GdJqjut82XEfjScFcJRFqB4w,8979
+fabricatio/models/extra/article_main.py,sha256=main-2eh-dH1SYN_zW2kFajMOrpatAVQVgQ-_7Yvsj4,11669
 fabricatio/models/extra/article_outline.py,sha256=w7O0SHgC7exbptWVbR62FMHAueMgBpyWKVYMGGl_oj8,1427
-fabricatio/models/extra/article_proposal.py,sha256=ZQh6rnlg-3C0GjjjYI08ptWXAzpfBDM0FyKHGDwjzgQ,2020
-fabricatio/models/extra/patches.py,sha256=-nBsse7g1astJh_IWZLXJdEQxpRla-DkHWqSHE-zbMU,989
+fabricatio/models/extra/article_proposal.py,sha256=NbyjW-7UiFPtnVD9nte75re4xL2pD4qL29PpNV4Cg_M,1870
+fabricatio/models/extra/patches.py,sha256=_WNCxtYzzsVfUxI16vu4IqsLahLYRHdbQN9er9tqhC0,997
 fabricatio/models/extra/problem.py,sha256=RyvHQM8XgMVqDT7BCtXU0SEgODWGvTPBQIoHOURF5Oc,6656
 fabricatio/models/extra/rule.py,sha256=ogJJYmV5F-CIRG2Dl95plgShskT8jzuh_0KWKHRonbA,2668
 fabricatio/models/extra/__init__.py,sha256=XlYnS_2B9nhLhtQkjE7rvvfPmAAtXVdNi9bSDAR-Ge8,54
-fabricatio/models/generic.py,sha256=6xBMU9BJGLwIaUfq74meu-rGmh5tPm4GIlYaju6jp2U,30038
+fabricatio/models/generic.py,sha256=7M1GZpgle7iwrSpzMmTBxpPx7zxCLH13l61h75woa_E,30237
 fabricatio/models/kwargs_types.py,sha256=sMDA85SoC1AOJ5k6qC8qUiUv0Ne0_5ThU9FZITRNen4,5673
 fabricatio/models/role.py,sha256=-CRcj5_M3_ciLPzwiNn92grBmwoSLQ-n4koVZiCNTBM,2953
 fabricatio/models/task.py,sha256=YXvO3upJkTqMQjPgUGfp0bIiSyZzek2f4IagHdMW5Ik,10491
 fabricatio/models/tool.py,sha256=jQ51g4lwTPfsMF1nbreDJtBczbxIHoXcPuLSOqHliq8,12506
-fabricatio/models/usages.py,sha256=JTE4mh9aJgkCdsjf4r4nqmhXkmCTDSoYoNiLnBq0958,31831
+fabricatio/models/usages.py,sha256=PX13lUCYB9XSM5tKrpYK-ov5jKclWlF9xGmPgUoovLk,32030
 fabricatio/models/utils.py,sha256=Ac5g-8ic6q_w7dhNuh-iiofpL1sqOACxbjPPTljP2LY,4417
-fabricatio/parser.py,sha256=UOSvXigEXK-eXsr3m3b7glOhbBWs4kDJTeTNyuqA9ic,6315
+fabricatio/parser.py,sha256=qN2godNsArmb90btOMxgqlol57166DyYsV2JlU8DlHs,6532
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fabricatio/rust.pyi,sha256=vXPgN8fSeoy_2jqUDzxP5ErTMpmFy-HieyN-dQj_OIM,6276
+fabricatio/rust.pyi,sha256=5xfla5dCACfKTkHztMc5_iCEmdDZtDH9HPG2YC92L8o,6266
 fabricatio/rust_instances.py,sha256=Byeo8KHW_dJiXujJq7YPGDLBX5bHNDYbBc4sY3uubVY,313
 fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
 fabricatio/toolboxes/fs.py,sha256=l4L1CVxJmjw9Ld2XUpIlWfV0_Fu_2Og6d3E13I-S4aE,736
@@ -56,6 +56,6 @@ fabricatio/workflows/articles.py,sha256=ObYTFUqLUk_CzdmmnX6S7APfxcGmPFqnFr9pdjU7
 fabricatio/workflows/rag.py,sha256=-YYp2tlE9Vtfgpg6ROpu6QVO8j8yVSPa6yDzlN3qVxs,520
 fabricatio/workflows/__init__.py,sha256=5ScFSTA-bvhCesj3U9Mnmi6Law6N1fmh5UKyh58L3u8,51
 fabricatio/__init__.py,sha256=Rmvq2VgdS2u68vnOi2i5RbeWbAwrJDbk8D8D883PJWE,1022
-fabricatio/rust.cp312-win_amd64.pyd,sha256=g1JviKFzajhMmCbXrUN8Rh_Z1Z13qo9Rh98Q7gZccXQ,2190848
-fabricatio-0.2.9.dev3.data/scripts/tdown.exe,sha256=pl4d193rlGA66vGBhZ4NdFh68Rr7rlBRJ-_sIldVce0,3390464
-fabricatio-0.2.9.dev3.dist-info/RECORD,,
+fabricatio/rust.cp312-win_amd64.pyd,sha256=5rWQDW_NkAoojnwNoStr9qIfa-JMcNlhEf1RLYSHM2o,2193920
+fabricatio-0.2.9.dev4.data/scripts/tdown.exe,sha256=bgxOSFt8NMWHddSQ27fn9f_AyO47PlYNcK1EuUJRYJo,3364864
+fabricatio-0.2.9.dev4.dist-info/RECORD,,