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

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,22 +15,33 @@ from fabricatio.models.extra.article_base import (
 from fabricatio.models.extra.article_outline import (
     ArticleOutline,
 )
-from fabricatio.models.generic import CensoredAble, Display, PersistentAble, SequencePatch, WithRef
+from fabricatio.models.generic import Described, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
+from fabricatio.rust import word_count
 from fabricatio.utils import ok
+from pydantic import Field
 
+PARAGRAPH_SEP = "// - - -"
 
-class Paragraph(CensoredAble):
+
+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."""
 
     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`."""
@@ -41,11 +53,28 @@ class ArticleSubsection(SubSectionBase):
     paragraphs: List[Paragraph]
     """List of Paragraph objects containing the content of the subsection."""
 
+    _max_word_count_deviation: float = 0.3
+    """Maximum allowed deviation from the expected word count, as a percentage."""
+
+    @property
+    def word_count(self) -> int:
+        """Calculates the total word count of all paragraphs in the subsection."""
+        return sum(word_count(p.content) for p in self.paragraphs)
+
     def introspect(self) -> str:
-        """Introspects the subsection and returns a message if it has no paragraphs."""
+        """Introspects the subsection and returns a summary of its state."""
+        summary = ""
         if len(self.paragraphs) == 0:
-            return f"`{self.__class__.__name__}` titled `{self.title}` have no paragraphs, to achieve the goal of `{self.writing_aim}`."
-        return ""
+            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.expected_word_count} words!"
+            )
+
+        return summary
 
     def update_from_inner(self, other: Self) -> Self:
         """Updates the current instance with the attributes of another instance."""
@@ -61,20 +90,62 @@ 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) -> 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),
+            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) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return cls(
+            subsections=[
+                ArticleSubsection.from_typst_code(*pack) for pack in extract_sections(body, level=3, section_char="=")
+            ],
+            heading=title,
+            elaboration="",
+            expected_word_count=word_count(body),
+            aims=[],
+            support_to=[],
+            depend_on=[],
+        )
+
 
 class ArticleChapter(ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
+    @classmethod
+    def from_typst_code(cls, title: str, body: str) -> Self:
+        """Creates an Article object from the given Typst code."""
+        return cls(
+            sections=[
+                ArticleSection.from_typst_code(*pack) for pack in extract_sections(body, level=2, section_char="=")
+            ],
+            heading=title,
+            elaboration="",
+            expected_word_count=word_count(body),
+            aims=[],
+            support_to=[],
+            depend_on=[],
+        )
+
 
 class Article(
-    Display,
-    CensoredAble,
+    SketchedAble,
     WithRef[ArticleOutline],
     PersistentAble,
     ArticleBase[ArticleChapter],
@@ -95,7 +166,7 @@ class Article(
 
     @override
     def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
-        return super().iter_subsections()
+        return super().iter_subsections()  # pyright: ignore [reportReturnType]
 
     @classmethod
     def from_outline(cls, outline: ArticleOutline) -> "Article":
@@ -108,31 +179,43 @@ 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(
+            chapters=[
+                ArticleChapter.from_typst_code(*pack) 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.
 
@@ -142,7 +225,7 @@ class Article(
 
         supports = []
         for a in self.iter_dfs_rev():
-            if article in {ok(b.deref(self)) for b in a.support_to}:
+            if article in {ok(b.deref(self)) for b in a.support_to}:  # pyright: ignore [reportUnhashable]
                 supports.append(a)
 
         return list(set(depends + supports))

fabricatio/models/extra/article_outline.py

@@ -9,7 +9,7 @@ from fabricatio.models.extra.article_base import (
     SubSectionBase,
 )
 from fabricatio.models.extra.article_proposal import ArticleProposal
-from fabricatio.models.generic import CensoredAble, Display, PersistentAble, WithRef
+from fabricatio.models.generic import PersistentAble, SketchedAble, WithRef
 
 
 class ArticleSubsectionOutline(SubSectionBase):
@@ -25,8 +25,7 @@ class ArticleChapterOutline(ChapterBase[ArticleSectionOutline]):
 
 
 class ArticleOutline(
-    Display,
-    CensoredAble,
+    SketchedAble,
     WithRef[ArticleProposal],
     PersistentAble,
     ArticleBase[ArticleChapterOutline],

fabricatio/models/extra/article_proposal.py

@@ -2,21 +2,25 @@
 
 from typing import Dict, List
 
-from fabricatio.models.generic import AsPrompt, CensoredAble, Display, PersistentAble, WithRef
-
-
-class ArticleProposal(CensoredAble, Display, 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(CensoredAble, Display, WithRef[str], AsPrompt, PersistentA
     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."""
 
-    min_word_count: int
-    """The minimum number of words required for the research proposal."""
-
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {
             "ArticleBriefing": self.referenced,

fabricatio/models/extra/patches.py

@@ -1,7 +1,20 @@
-"""A patch class for updating the description and name of a `WithBriefing` object."""
+"""A patch class for updating the description and name of a `WithBriefing` object, all fields within this instance will be directly copied onto the target model's field."""
 
-from fabricatio.models.generic import Patch, WithBriefing
+from typing import Optional, Type
 
+from fabricatio.models.extra.rule import RuleSet
+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."""
+
+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 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."""
+        return RuleSet

fabricatio/models/extra/problem.py

@@ -1,11 +1,12 @@
 """A class representing a problem-solution pair identified during a review process."""
 
 from itertools import chain
-from typing import List, Literal, Optional, Self
+from typing import Any, List, Optional, Self, Tuple, Unpack
 
 from fabricatio.journal import logger
 from fabricatio.models.generic import SketchedAble, WithBriefing
 from fabricatio.utils import ask_edit
+from pydantic import Field
 from questionary import Choice, checkbox, text
 from rich import print as r_print
 
@@ -13,36 +14,30 @@ from rich import print as r_print
 class Problem(SketchedAble, WithBriefing):
     """Represents a problem identified during review."""
 
-    description: str
-    """Description of the problem, The """
+    description: str = Field(alias="cause")
+    """The cause of the problem, including the root cause, the context, and the impact, make detailed enough for engineer to understand the problem and its impact."""
 
-    severity: Literal["low", "medium", "high"]
-    """Severity level of the problem."""
-
-    category: str
-    """Category of the problem."""
+    severity_level: int = Field(ge=0, le=10)
+    """Severity level of the problem, which is a number between 0 and 10, 0 means the problem is not severe, 10 means the problem is extremely severe."""
 
     location: str
     """Location where the problem was identified."""
 
-    recommendation: str
-    """Recommended solution or action."""
-
 
 class Solution(SketchedAble, WithBriefing):
     """Represents a proposed solution to a problem."""
 
-    description: str
+    description: str = Field(alias="mechanism")
     """Description of the solution, including a detailed description of the execution steps, and the mechanics, principle or fact."""
 
     execute_steps: List[str]
-    """A list of steps to execute to implement the solution, which is expected to be able to finally solve the corresponding problem."""
+    """A list of steps to execute to implement the solution, which is expected to be able to finally solve the corresponding problem, and which should be an Idiot-proof tutorial."""
 
-    feasibility: Literal["low", "medium", "high"]
-    """Feasibility level of the solution."""
+    feasibility_level: int = Field(ge=0, le=10)
+    """Feasibility level of the solution, which is a number between 0 and 10, 0 means the solution is not feasible, 10 means the solution is complete feasible."""
 
-    impact: Literal["low", "medium", "high"]
-    """Impact level of the solution."""
+    impact_level: int = Field(ge=0, le=10)
+    """Impact level of the solution, which is a number between 0 and 10, 0 means the solution is not impactful, 10 means the solution is extremely impactful."""
 
 
 class ProblemSolutions(SketchedAble):
@@ -51,7 +46,12 @@ class ProblemSolutions(SketchedAble):
     problem: Problem
     """The problem identified in the review."""
     solutions: List[Solution]
-    """A collection of potential solutions."""
+    """A collection of potential solutions, spread the thought, add more solution as possible.Do not leave this as blank"""
+
+    def model_post_init(self, context: Any, /) -> None:
+        """Initialize the problem-solution pair with a problem and a list of solutions."""
+        if len(self.solutions) == 0:
+            logger.warning(f"No solution found for problem {self.problem.name}, please add more solutions manually.")
 
     def update_from_inner(self, other: Self) -> Self:
         """Update the current instance with another instance's attributes."""
@@ -69,6 +69,10 @@ class ProblemSolutions(SketchedAble):
         self.solutions = solutions
         return self
 
+    def has_solutions(self) -> bool:
+        """Check if the problem-solution pair has any solutions."""
+        return len(self.solutions) > 0
+
     async def edit_problem(self) -> Self:
         """Interactively edit the problem description."""
         self.problem = Problem.model_validate_strings(
@@ -87,11 +91,11 @@ class ProblemSolutions(SketchedAble):
         """Check if the improvement is decided."""
         return len(self.solutions) == 1
 
-    def final_solution(self) -> Optional[Solution]:
+    def final_solution(self, always_use_first: bool = False) -> Optional[Solution]:
         """Get the final solution."""
-        if not self.decided():
+        if not always_use_first and not self.decided():
             logger.error(
-                f"There is more than one solution for problem {self.problem.name}, please decide which solution is eventually adopted."
+                f"There is {len(self.solutions)} solutions for problem {self.problem.name}, please decide which solution is eventually adopted."
             )
             return None
         return self.solutions[0]
@@ -106,6 +110,10 @@ class Improvement(SketchedAble):
     problem_solutions: List[ProblemSolutions]
     """Collection of problems identified during review along with their potential solutions."""
 
+    def all_problems_have_solutions(self) -> bool:
+        """Check if all problems have solutions."""
+        return all(ps.has_solutions() for ps in self.problem_solutions)
+
     async def supervisor_check(self, check_solutions: bool = True) -> Self:
         """Perform an interactive review session to filter problems and solutions.
 
@@ -145,9 +153,9 @@ class Improvement(SketchedAble):
         return all(ps.decided() for ps in self.problem_solutions)
 
     @classmethod
-    def gather(cls, *improvements: Self) -> Self:
+    def gather(cls, *improvements: Unpack[Tuple["Improvement", ...]]) -> Self:
         """Gather multiple improvements into a single instance."""
         return cls(
-            focused_on="\n".join(imp.focused_on for imp in improvements),
+            focused_on=";".join(imp.focused_on for imp in improvements),
             problem_solutions=list(chain(*(imp.problem_solutions for imp in improvements))),
         )

fabricatio/models/extra/rule.py

@@ -1,21 +1,52 @@
-"""A module containing classes related to rule sets and rules."""
+"""A module containing classes related to rule sets and rules.
 
-from typing import List
+This module provides the `Rule` and `RuleSet` classes, which are used to define and manage
+individual rules and collections of rules, respectively. These classes are designed to
+facilitate the creation, organization, and application of rules in various contexts,
+ensuring clarity, consistency, and enforceability. The module supports detailed
+descriptions, examples, and metadata for each rule and rule set, making it suitable for
+complex rule management systems.
+"""
 
-from fabricatio.models.generic import Display, PersistentAble, ProposedAble, WithBriefing
+from typing import List, Self, Tuple, Unpack
 
+from fabricatio.models.generic import Language, PersistentAble, SketchedAble, WithBriefing
+from more_itertools import flatten
 
-class Rule(WithBriefing,ProposedAble,Display):
+
+class Rule(WithBriefing, Language, SketchedAble, PersistentAble):
     """Represents a rule or guideline for a specific topic."""
 
     violation_examples: List[str]
-    """Examples of violations of the rule."""
+    """A list of concrete examples demonstrating violations of this rule. Each example should
+    be a clear scenario or case that illustrates how the rule can be broken, including the
+    context, actions, and consequences of the violation. These examples should help in
+    understanding the boundaries of the rule."""
+
     compliance_examples: List[str]
-    """Examples of how to comply with the rule."""
+    """A list of concrete examples demonstrating proper compliance with this rule. Each example
+    should be a clear scenario or case that illustrates how to correctly follow the rule,
+    including the context, actions, and positive outcomes of compliance. These examples should
+    serve as practical guidance for implementing the rule correctly."""
 
 
-class RuleSet(ProposedAble, Display, PersistentAble, WithBriefing):
+class RuleSet(SketchedAble, PersistentAble, WithBriefing, Language):
     """Represents a collection of rules and guidelines for a particular topic."""
 
     rules: List[Rule]
-    """The rules and guidelines contained in the rule set."""
+    """The collection of rules and guidelines contained in this rule set. Each rule should be
+    a well-defined, specific guideline that contributes to the overall purpose of the rule set.
+    The rules should be logically organized and consistent with each other, forming a coherent
+    framework for the topic or domain covered by the rule set."""
+
+    @classmethod
+    def gather(cls, *rulesets: Unpack[Tuple["RuleSet",...]]) -> Self:
+        """Gathers multiple rule sets into a single rule set."""
+        if not rulesets:
+            raise ValueError("No rulesets provided")
+        return cls(
+            language=rulesets[0].language,
+            name=";".join(ruleset.name for ruleset in rulesets),
+            description=";".join(ruleset.description for ruleset in rulesets),
+            rules=list(flatten(r.rules for r in rulesets)),
+        )