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

fabricatio/models/extra/article_outline.py

@@ -1,30 +1,27 @@
 """A module containing the ArticleOutline class, which represents the outline of an academic paper."""
 
-from typing import Generator, List, Optional, Tuple, Union
+from typing import Dict
 
-import regex
 from fabricatio.models.extra.article_base import (
     ArticleBase,
-    ArticleOutlineBase,
     ChapterBase,
     SectionBase,
     SubSectionBase,
 )
 from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.generic import CensoredAble, Display, PersistentAble, WithRef
-from fabricatio.models.utils import ok
 
 
-class ArticleSubsectionOutline(ArticleOutlineBase, SubSectionBase):
+class ArticleSubsectionOutline(SubSectionBase):
     """Atomic research component specification for academic paper generation."""
 
 
-class ArticleSectionOutline(ArticleOutlineBase, SectionBase[ArticleSubsectionOutline]):
-    """A slightly more detailed research component specification for academic paper generation."""
+class ArticleSectionOutline(SectionBase[ArticleSubsectionOutline]):
+    """A slightly more detailed research component specification for academic paper generation, Must contain subsections."""
 
 
-class ArticleChapterOutline(ArticleOutlineBase, ChapterBase[ArticleSectionOutline]):
-    """Macro-structural unit implementing standard academic paper organization."""
+class ArticleChapterOutline(ChapterBase[ArticleSectionOutline]):
+    """Macro-structural unit implementing standard academic paper organization. Must contain sections."""
 
 
 class ArticleOutline(
@@ -34,148 +31,11 @@ class ArticleOutline(
     PersistentAble,
     ArticleBase[ArticleChapterOutline],
 ):
-    """Complete academic paper blueprint with hierarchical validation."""
+    """Outline of an academic paper, containing chapters, sections, subsections."""
 
-    abstract: str
-    """The abstract is a concise summary of the academic paper's main findings."""
-
-    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
-    """
-
-    title: str
-    """Title of the academic paper."""
-
-    language: str
-    """Written language of the article. SHALL be aligned to the language of the article proposal provided."""
-
-    def finalized_dump(self) -> str:
-        """Generates standardized hierarchical markup for academic publishing systems.
-
-        Implements ACL 2024 outline conventions with four-level structure:
-        = Chapter Title (Level 1)
-        == Section Title (Level 2)
-        === Subsection Title (Level 3)
-        ==== Subsubsection Title (Level 4)
-
-        Returns:
-            str: Strictly formatted outline with academic sectioning
-
-        Example:
-            = Methodology
-            == Neural Architecture Search Framework
-            === Differentiable Search Space
-            ==== Constrained Optimization Parameters
-            === Implementation Details
-            == Evaluation Protocol
-        """
-        lines: List[str] = []
-        for i, chapter in enumerate(self.chapters, 1):
-            lines.append(f"= Chapter {i}: {chapter.title}")
-            for j, section in enumerate(chapter.sections, 1):
-                lines.append(f"== {i}.{j} {section.title}")
-                for k, subsection in enumerate(section.subsections, 1):
-                    lines.append(f"=== {i}.{j}.{k} {subsection.title}")
-        return "\n".join(lines)
-
-    def iter_dfs(self) -> Generator[ArticleOutlineBase, None, None]:
-        """Iterates through the article outline in a depth-first manner.
-
-        Returns:
-            ArticleOutlineBase: Each component in the article outline.
-        """
-        for chapter in self.chapters:
-            for section in chapter.sections:
-                yield from section.subsections
-                yield section
-            yield chapter
-
-    def resolve_ref_error(self) -> str:
-        """Resolve reference errors in the article outline.
-
-        Returns:
-            str: Error message indicating reference errors in the article outline.
-
-        Notes:
-            This function is designed to find all invalid `ArticleRef` objs in `depend_on` and `support_to` fields, which will be added to the final error summary.
-        """
-        summary = ""
-        for component in self.iter_dfs():
-            for ref in component.depend_on:
-                if not ref.deref(self):
-                    summary += f"Invalid internal reference in {component.__class__.__name__} titled `{component.title}` at `depend_on` field, because the referred {ref.referring_type} is not exists within the article, see the original obj dump: {ref.model_dump()}\n"
-            for ref in component.support_to:
-                if not ref.deref(self):
-                    summary += f"Invalid internal reference in {component.__class__.__name__} titled `{component.title}` at `support_to` field, because the referred {ref.referring_type} is not exists within the article, see the original obj dump: {ref.model_dump()}\n"
-
-        return summary
-
-    @classmethod
-    def from_typst_code(
-        cls, typst_code: str, title: str = "", article_language: str = "en", prospect: str = "", abstract: str = ""
-    ) -> "ArticleOutline":
-        """Parses a Typst code string and creates an ArticleOutline instance."""
-        self = cls(language=article_language, prospect=prospect, abstract=abstract, chapters=[], title=title)
-        stack = [self]  # 根节点为ArticleOutline实例
-
-        for line in typst_code.splitlines():
-            parsed = cls._parse_line(line)
-            if not parsed:
-                continue
-            level, title = parsed
-            cls._adjust_stack(stack, level)
-            parent = stack[-1]
-            component = cls._create_component(level, title)
-            cls._add_to_parent(parent, component, level)
-            stack.append(component)
-
-        return self
-
-    @classmethod
-    def _parse_line(cls, line: str) -> Optional[Tuple[int, str]]:
-        stripped = line.strip()
-        if not stripped.startswith("="):
-            return None
-        match = regex.match(r"^(\=+)(.*)", stripped)
-        if not match:
-            return None
-        eqs, title_part = match.groups()
-        return len(eqs), title_part.strip()
-
-    @classmethod
-    def _adjust_stack(cls, stack: List[object], target_level: int) -> None:
-        while len(stack) > target_level:
-            stack.pop()
-
-    @classmethod
-    def _create_component(cls, level: int, title: str) -> ArticleOutlineBase:
-        default_kwargs = {
-            "writing_aim": [],
-            "depend_on": [],
-            "support_to": [],
-            "description": [],
+    def _as_prompt_inner(self) -> Dict[str, str]:
+        return {
+            "Original Article Briefing": self.referenced.referenced,
+            "Original Article Proposal": self.referenced.display(),
+            "Original Article Outline": self.display(),
         }
-        component_map = {
-            1: lambda: ArticleChapterOutline(title=title, sections=[], **default_kwargs),
-            2: lambda: ArticleSectionOutline(title=title, subsections=[], **default_kwargs),
-            3: lambda: ArticleSubsectionOutline(title=title, **default_kwargs),
-        }
-        return ok(component_map.get(level, lambda: None)(), "Invalid level")
-
-    @classmethod
-    def _add_to_parent(
-        cls,
-        parent: Union["ArticleOutline", ArticleChapterOutline, ArticleSectionOutline],
-        component: ArticleOutlineBase,
-        level: int,
-    ) -> None:
-        if level == 1 and isinstance(component, ArticleChapterOutline):
-            parent.chapters.append(component)
-        elif level == 2 and isinstance(component, ArticleSectionOutline):  # noqa: PLR2004
-            parent.sections.append(component)
-        elif level == 3 and isinstance(component, ArticleSubsectionOutline):  # noqa: PLR2004
-            parent.subsections.append(component)

fabricatio/models/extra/article_proposal.py

@@ -11,25 +11,41 @@ class ArticleProposal(CensoredAble, Display, WithRef[str], AsPrompt, PersistentA
     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."""
+
     technical_approaches: List[str]
-    """Technical approaches"""
+    """A list of technical approaches or methodologies used to solve the research problems."""
 
     research_methods: List[str]
-    """Methodological components (list of techniques/tools).
-    Example: ['Differentiable architecture search', 'Transformer-based search space', 'Multi-lingual perplexity evaluation']"""
+    """A list of methodological components, including techniques and tools utilized in the research."""
 
     research_aim: List[str]
-    """Primary research objectives (list of 2-4 measurable goals).
-    Example: ['Develop parameter-efficient NAS framework', 'Establish cross-lingual architecture transfer metrics']"""
+    """A list of primary research objectives that the paper seeks to achieve."""
 
-    focused_problem: List[str]
-    """Specific research problem(s) or question(s) addressed (list of 1-3 concise statements).
-    Example: ['NAS computational overhead in low-resource settings', 'Architecture transferability across language pairs']"""
+    literature_review: List[str]
+    """A list of key references and literature that support the research context and background."""
 
-    title: str
-    """Paper title in academic style (Title Case, 8-15 words). Example: 'Exploring Neural Architecture Search for Low-Resource Machine Translation'"""
-    language: str
-    """Written language of the article. SHALL be aligned to the language of the article briefing provided."""
+    expected_outcomes: List[str]
+    """A list of anticipated results or contributions that the research aims to achieve."""
+
+    keywords: List[str]
+    """A list of keywords that represent the main topics and focus areas of the research."""
+
+    abstract: str
+    """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, "ArticleProposal": self.display()}
+        return {
+            "ArticleBriefing": self.referenced,
+            "ArticleProposal": self.display(),
+        }

fabricatio/models/extra/patches.py

@@ -0,0 +1,7 @@
+"""A patch class for updating the description and name of a `WithBriefing` object."""
+
+from fabricatio.models.generic import Patch, WithBriefing
+
+
+class BriefingPatch[T:WithBriefing](Patch[T], WithBriefing):
+    """Patch class for updating the description and name of a `WithBriefing` object."""

fabricatio/models/extra/problem.py

@@ -0,0 +1,153 @@
+"""A class representing a problem-solution pair identified during a review process."""
+
+from itertools import chain
+from typing import List, Literal, Optional, Self
+
+from fabricatio.journal import logger
+from fabricatio.models.generic import SketchedAble, WithBriefing
+from fabricatio.utils import ask_edit
+from questionary import Choice, checkbox, text
+from rich import print as r_print
+
+
+class Problem(SketchedAble, WithBriefing):
+    """Represents a problem identified during review."""
+
+    description: str
+    """Description of the problem, The """
+
+    severity: Literal["low", "medium", "high"]
+    """Severity level of the problem."""
+
+    category: str
+    """Category of the problem."""
+
+    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 of the solution, including a detailed description of the execution steps, and the mechanics, principle or fact."""
+
+    execute_steps: List[str]
+    """A list of steps to execute to implement the solution, which is expected to be able to finally solve the corresponding problem."""
+
+    feasibility: Literal["low", "medium", "high"]
+    """Feasibility level of the solution."""
+
+    impact: Literal["low", "medium", "high"]
+    """Impact level of the solution."""
+
+
+class ProblemSolutions(SketchedAble):
+    """Represents a problem-solution pair identified during a review process."""
+
+    problem: Problem
+    """The problem identified in the review."""
+    solutions: List[Solution]
+    """A collection of potential solutions."""
+
+    def update_from_inner(self, other: Self) -> Self:
+        """Update the current instance with another instance's attributes."""
+        self.solutions.clear()
+        self.solutions.extend(other.solutions)
+        return self
+
+    def update_problem(self, problem: Problem) -> Self:
+        """Update the problem description."""
+        self.problem = problem
+        return self
+
+    def update_solutions(self, solutions: List[Solution]) -> Self:
+        """Update the list of potential solutions."""
+        self.solutions = solutions
+        return self
+
+    async def edit_problem(self) -> Self:
+        """Interactively edit the problem description."""
+        self.problem = Problem.model_validate_strings(
+            await text("Please edit the problem below:", default=self.problem.display()).ask_async()
+        )
+        return self
+
+    async def edit_solutions(self) -> Self:
+        """Interactively edit the list of potential solutions."""
+        r_print(self.problem.display())
+        string_seq = await ask_edit([s.display() for s in self.solutions])
+        self.solutions = [Solution.model_validate_strings(s) for s in string_seq]
+        return self
+
+    def decided(self) -> bool:
+        """Check if the improvement is decided."""
+        return len(self.solutions) == 1
+
+    def final_solution(self) -> Optional[Solution]:
+        """Get the final solution."""
+        if not self.decided():
+            logger.error(
+                f"There is more than one solution for problem {self.problem.name}, please decide which solution is eventually adopted."
+            )
+            return None
+        return self.solutions[0]
+
+
+class Improvement(SketchedAble):
+    """A class representing an improvement suggestion."""
+
+    focused_on: str
+    """The focused on topic of the improvement"""
+
+    problem_solutions: List[ProblemSolutions]
+    """Collection of problems identified during review along with their potential solutions."""
+
+    async def supervisor_check(self, check_solutions: bool = True) -> Self:
+        """Perform an interactive review session to filter problems and solutions.
+
+        Presents an interactive prompt allowing a supervisor to select which
+        problems (and optionally solutions) should be retained in the final review.
+
+        Args:
+            check_solutions (bool, optional): When True, also prompts for filtering
+                individual solutions for each retained problem. Defaults to False.
+
+        Returns:
+            Self: The current instance with filtered problems and solutions.
+        """
+        # Choose the problems to retain
+        chosen_ones: List[ProblemSolutions] = await checkbox(
+            "Please choose the problems you want to retain.(Default: retain all)",
+            choices=[Choice(p.problem.name, p, checked=True) for p in self.problem_solutions],
+        ).ask_async()
+        self.problem_solutions = [await p.edit_problem() for p in chosen_ones]
+        if not check_solutions:
+            return self
+
+        # Choose the solutions to retain
+        for to_exam in self.problem_solutions:
+            to_exam.update_solutions(
+                await checkbox(
+                    f"Please choose the solutions you want to retain.(Default: retain all)\n\t`{to_exam.problem}`",
+                    choices=[Choice(s.name, s, checked=True) for s in to_exam.solutions],
+                ).ask_async()
+            )
+            await to_exam.edit_solutions()
+
+        return self
+
+    def decided(self) -> bool:
+        """Check if the improvement is decided."""
+        return all(ps.decided() for ps in self.problem_solutions)
+
+    @classmethod
+    def gather(cls, *improvements: Self) -> Self:
+        """Gather multiple improvements into a single instance."""
+        return cls(
+            focused_on="\n".join(imp.focused_on for imp in improvements),
+            problem_solutions=list(chain(*(imp.problem_solutions for imp in improvements))),
+        )

fabricatio/models/extra/rule.py

@@ -0,0 +1,65 @@
+"""A module containing classes related to rule sets and rules.
+
+This module provides the `Rule` and `RuleSet` classes, which are used to define and manage
+individual rules and collections of rules, respectively. These classes are designed to
+facilitate the creation, organization, and application of rules in various contexts,
+ensuring clarity, consistency, and enforceability. The module supports detailed
+descriptions, examples, and metadata for each rule and rule set, making it suitable for
+complex rule management systems.
+"""
+
+
+from typing import List
+
+from fabricatio.models.generic import PersistentAble, SketchedAble, WithBriefing
+
+
+class Rule(WithBriefing, SketchedAble):
+    """Represents a rule or guideline for a specific topic.
+
+    The `Rule` class encapsulates a single rule, providing detailed information about its
+    purpose, scope, and application. It includes fields for a comprehensive description,
+    examples of violations, and examples of compliance. This class is designed to ensure
+    that rules are clearly defined, well-documented, and easy to understand and enforce.
+    """
+
+    description: str
+    """A comprehensive description of the rule, including its purpose, scope, and context.
+    This should clearly explain what the rule is about, why it exists, and in what situations
+    it applies. The description should be detailed enough to provide full understanding of
+    the rule's intent and application."""
+
+    violation_examples: List[str]
+    """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]
+    """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(SketchedAble, PersistentAble, WithBriefing):
+    """Represents a collection of rules and guidelines for a particular topic.
+
+    The `RuleSet` class is used to group related rules into a coherent set, providing a
+    structured way to manage and apply multiple rules. It includes a description of the
+    overall purpose and scope of the rule set, as well as a list of individual rules. This
+    class is designed to ensure that rule sets are well-organized, consistent, and easy to
+    navigate and enforce.
+    """
+
+    description: str
+    """A comprehensive description of the rule set, including its overall purpose, scope, and
+    context. This should explain why this collection of rules exists, what domain or topic it
+    covers, and how the rules within the set are related to each other. The description should
+    provide a clear understanding of the rule set's intent and application."""
+
+    rules: List[Rule]
+    """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."""