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

fabricatio/models/extra/article_essence.py

@@ -1,226 +1,99 @@
 """ArticleEssence: Semantic fingerprint of academic paper for structured analysis."""
 
-from typing import List
+from typing import List, Self
 
-from fabricatio.models.generic import Display, PrepareVectorization, ProposedAble
-from pydantic import BaseModel, Field
+from fabricatio.models.generic import Display, PersistentAble, ProposedAble, Vectorizable
+from pydantic import BaseModel
 
 
 class Equation(BaseModel):
-    """Mathematical formalism specification for research contributions.
-
-    Encodes equations with dual representation: semantic meaning and typeset-ready notation.
-    """
+    """Mathematical formalism specification for research contributions."""
 
     description: str
-    """Equation significance structured in three elements:
-    1. Physical/conceptual meaning of the equation.
-    2. Role in technical workflow (e.g., derivation, optimization, or analysis).
-    3. Relationship to the paper's core contribution (e.g., theoretical foundation, empirical validation).
-    Example: "Defines constrained search space dimensionality reduction. Used in architecture optimization phase (Section 3.2). Enables 40% parameter reduction."
+    """Structured significance including:
+    1. Conceptual meaning
+    2. Technical workflow role
+    3. Contribution relationship
     """
 
     latex_code: str
-    """LaTeX representation following academic typesetting standards:
-    - Must use equation environment (e.g., `equation`, `align`).
-    - Multiline equations must align at '=' using `&`.
-    - Include unit annotations where applicable.
-    Example: "\\begin{equation} \\mathcal{L}_{NAS} = \\alpha \\|\\theta\\|_2 + \\beta H(p) \\end{equation}"
-    """
+    """Typeset-ready notation."""
 
 
 class Figure(BaseModel):
-    """Visual component specification for technical communication.
-
-    Combines graphical assets with structured academic captioning.Extracted from the article provided
-    """
+    """Visual component with academic captioning."""
 
     description: str
-    """Figure interpretation guide containing:
-    1. Key visual elements mapping (e.g., axes, legends, annotations).
-    2. Data representation methodology (e.g., visualization type, statistical measures).
-    3. Connection to research findings (e.g., supports hypothesis, demonstrates performance).
-    Example: "Architecture search space topology (left) vs. convergence curves (right). Demonstrates NAS efficiency gains through constrained search."
+    """Interpretation guide covering:
+    1. Visual element mapping
+    2. Data representation method
+    3. Research connection
     """
 
     figure_caption: str
-    """Complete caption following Nature-style guidelines:
-    1. Brief overview statement (首句总结).
-    2. Technical detail layer (e.g., data sources, experimental conditions).
-    3. Result implication (e.g., key insights, implications for future work).
-    Example: "Figure 3: Differentiable NAS framework. (a) Search space topology with constrained dimensions. (b) Training convergence across language pairs. Dashed lines indicate baseline methods."
+    """Nature-style caption containing:
+    1. Overview statement
+    2. Technical details
+    3. Result implications
     """
 
     figure_serial_number: int
-    """The Image serial number extracted from the Markdown article provided, the path usually in the form of `![](images/1.jpg)`, in this case the serial number is `1`"""
-
-
-class Algorithm(BaseModel):
-    """Algorithm specification for research contributions."""
-
-    title: str
-    """Algorithm title with technical focus descriptor (e.g., 'Gradient Descent Optimization').
-
-    Tip: Do not attempt to translate the original element titles when generating JSON.
-    """
-
-    description: str
-    """Algorithm description with technical focus descriptor:
-    - Includes input/output specifications.
-    - Describes key steps and their purpose.
-    - Explains its role in the research workflow.
-    Example: "Proposed algorithm for neural architecture search. Inputs include search space constraints and training data. Outputs optimized architecture."
-    """
-
-
-class Table(BaseModel):
-    """Table specification for research contributions."""
-
-    title: str
-    """Table title with technical focus descriptor (e.g., 'Comparison of Model Performance Metrics').
-
-    Tip: Do not attempt to translate the original element titles when generating JSON.
-    """
-
-    description: str
-    """Table description with technical focus descriptor:
-    - Includes data source and structure.
-    - Explains key columns/rows and their significance.
-    - Connects to research findings or hypotheses.
-    Example: "Performance metrics for different architectures. Columns represent accuracy, F1-score, and inference time. Highlights efficiency gains of proposed method."
-    """
+    """Image serial number extracted from Markdown path"""
 
 
 class Highlightings(BaseModel):
-    """Technical showcase aggregator for research artifacts.
-
-    Curates core scientific components with machine-parseable annotations.
-    """
+    """Technical component aggregator."""
 
     highlighted_equations: List[Equation]
-    """3-5 pivotal equations representing theoretical contributions:
-    - Each equation must be wrapped in $$ for display math.
-    - Contain at least one novel operator/symbol.
-    - Be referenced in Methods/Results sections.
-    Example: Equation describing proposed loss function.
-    """
-
-    highlighted_algorithms: List[Algorithm]
-    """1-2 key algorithms demonstrating methodological contributions:
-    - Include pseudocode or step-by-step descriptions.
-    - Highlight innovation in computational approach.
-    Example: Algorithm for constrained search space exploration.
-
-    Tip: Do not attempt to translate the original element titles when generating JSON.
-    """
+    """Equations that highlight the article's core contributions"""
 
     highlighted_figures: List[Figure]
-    """4-6 key figures demonstrating:
-    1. Framework overview (1 required).
-    2. Quantitative results (2-3 required).
-    3. Ablation studies (1 optional).
-    Each must appear in Results/Discussion chapters.
-    Example: Figure showing architecture topology and convergence curves.
+    """key figures requiring:
+    1. Framework overview
+    2. Quantitative results
     """
 
-    highlighted_tables: List[Table]
-    """2-3 key tables summarizing:
-    - Comparative analysis of methods.
-    - Empirical results supporting claims.
-    Example: Table comparing model performance across datasets.
-
-    Tip: Do not attempt to translate the original element titles when generating JSON.
-    """
 
+class ArticleEssence(ProposedAble, Display, PersistentAble, Vectorizable):
+    """Structured representation of a scientific article's core elements in its original language."""
 
-class ArticleEssence(ProposedAble, Display, PrepareVectorization):
-    """Semantic fingerprint of academic paper for structured analysis.
+    language: str
+    """Language of the original article."""
 
-    Encodes research artifacts with dual human-machine interpretability.
-    """
-
-    title: str = Field(...)
-    """Exact title of the original article without any modification.
-    Must be preserved precisely from the source material without:
-    - Translation
-    - Paraphrasing
-    - Adding/removing words
-    - Altering style or formatting
-    """
+    title: str
+    """Exact title of the original article."""
 
     authors: List[str]
-    """Original author names exactly as they appear in the source document. No translation or paraphrasing.
-    Extract complete list without any modifications or formatting changes."""
+    """Original author full names as they appear in the source document."""
 
     keywords: List[str]
-    """Original keywords exactly as they appear in the source document. No translation or paraphrasing.
-    Extract the complete set without modifying format or terminology."""
+    """Original keywords as they appear in the source document."""
 
     publication_year: int
-    """Publication timestamp in ISO 8601 (YYYY format)."""
+    """Publication year in ISO 8601 (YYYY format)."""
 
     highlightings: Highlightings
-    """Technical highlight reel containing:
-    - Core equations (Theory)
-    - Key algorithms (Implementation)
-    - Critical figures (Results)
-    - Benchmark tables (Evaluation)"""
-
-    domain: List[str]
-    """Domain tags for research focus."""
-
-    abstract: str = Field(...)
-    """Three-paragraph structured abstract:
-    Paragraph 1: Problem & Motivation (2-3 sentences)
-    Paragraph 2: Methodology & Innovations (3-4 sentences)
-    Paragraph 3: Results & Impact (2-3 sentences)
-    Total length: 150-250 words"""
+    """Technical highlights including equations, algorithms, figures, and tables."""
+
+    abstract: str
+    """Abstract text in the original language."""
 
     core_contributions: List[str]
-    """3-5 technical contributions using CRediT taxonomy verbs.
-    Each item starts with action verb.
-    Example:
-    - 'Developed constrained NAS framework'
-    - 'Established cross-lingual transfer metrics'"""
+    """Technical contributions using CRediT taxonomy verbs."""
 
     technical_novelty: List[str]
-    """Patent-style claims with technical specificity.
-    Format: 'A [system/method] comprising [novel components]...'
-    Example:
-    'A neural architecture search system comprising:
-     a differentiable constrained search space;
-     multi-lingual transferability predictors...'"""
+    """Patent-style claims with technical specificity."""
 
     research_problems: List[str]
-    """Problem statements as how/why questions.
-    Example:
-    - 'How to reduce NAS computational overhead while maintaining search diversity?'
-    - 'Why do existing architectures fail in low-resource cross-lingual transfer?'"""
+    """Problem statements as how/why questions."""
 
     limitations: List[str]
-    """Technical limitations analysis containing:
-    1. Constraint source (data/method/theory)
-    2. Impact quantification
-    3. Mitigation pathway
-    Example:
-    'Methodology constraint: Single-objective optimization (affects 5% edge cases),
-    mitigated through future multi-task extension'"""
-
-    future_work: List[str]
-    """Research roadmap items with 3 horizons:
-    1. Immediate extensions (1 year)
-    2. Mid-term directions (2-3 years)
-    3. Long-term vision (5+ years)
-    Example:
-    'Short-term: Adapt framework for vision transformers (ongoing with CVPR submission)'"""
-
-    impact_analysis: List[str]
-    """Bibliometric impact projections:
-    - Expected citation counts (next 3 years)
-    - Target application domains
-    - Standard adoption potential
-    Example:
-    'Predicted 150+ citations via integration into MMEngine (Alibaba OpenMMLab)'"""
-
-    def _prepare_vectorization_inner(self) -> str:
-        return self.model_dump_json()
+    """Technical limitations analysis."""
+
+    bibtex_cite_key: str
+    """Bibtex cite key of the original article."""
+
+    def update_cite_key(self, new_cite_key: str) -> Self:
+        """Update the bibtex_cite_key of the article."""
+        self.bibtex_cite_key = new_cite_key
+        return self

fabricatio/models/extra/article_main.py

@@ -1,13 +1,12 @@
 """ArticleBase and ArticleSubsection classes for managing hierarchical document components."""
 
 from itertools import chain
-from typing import Generator, List, Self, Tuple, override
+from typing import Dict, Generator, List, Self, Tuple, override
 
 from fabricatio.journal import logger
 from fabricatio.models.extra.article_base import (
     ArticleBase,
     ArticleOutlineBase,
-    ArticleRef,
     ChapterBase,
     SectionBase,
     SubSectionBase,
@@ -15,8 +14,8 @@ from fabricatio.models.extra.article_base import (
 from fabricatio.models.extra.article_outline import (
     ArticleOutline,
 )
-from fabricatio.models.generic import CensoredAble, Display, PersistentAble, WithRef
-from fabricatio.models.utils import ok
+from fabricatio.models.generic import CensoredAble, Display, PersistentAble, SequencePatch, WithRef
+from fabricatio.utils import ok
 
 
 class Paragraph(CensoredAble):
@@ -28,21 +27,30 @@ class Paragraph(CensoredAble):
     writing_aim: List[str]
     """Specific communicative objectives for this paragraph's content."""
 
-    sentences: List[str]
-    """List of sentences forming the paragraph's content."""
+    content: str
+    """The actual content of the paragraph, represented as a string."""
 
 
-class ArticleSubsection(ArticleOutlineBase, SubSectionBase):
+class ArticleParagraphSequencePatch(SequencePatch[Paragraph]):
+    """Patch for `Paragraph` list of `ArticleSubsection`."""
+
+
+class ArticleSubsection(SubSectionBase):
     """Atomic argumentative unit with technical specificity."""
 
     paragraphs: List[Paragraph]
     """List of Paragraph objects containing the content of the subsection."""
 
+    def introspect(self) -> str:
+        """Introspects the subsection and returns a message if it has no paragraphs."""
+        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 ""
+
     def update_from_inner(self, other: Self) -> Self:
         """Updates the current instance with the attributes of another instance."""
         logger.debug(f"Updating SubSection {self.title}")
-        SubSectionBase.update_from(self, other)
-        ArticleOutlineBase.update_from(self, other)
+        super().update_from_inner(other)
         self.paragraphs.clear()
         self.paragraphs.extend(other.paragraphs)
         return self
@@ -53,19 +61,17 @@ class ArticleSubsection(ArticleOutlineBase, SubSectionBase):
         Returns:
             str: Typst code snippet for rendering.
         """
-        return f"=== {self.title}\n" + "\n\n".join("".join(p.sentences) for p in self.paragraphs)
+        return f"=== {self.title}\n" + "\n\n".join(p.content for p in self.paragraphs)
 
 
-class ArticleSection(ArticleOutlineBase, SectionBase[ArticleSubsection]):
+class ArticleSection(SectionBase[ArticleSubsection]):
     """Atomic argumentative unit with high-level specificity."""
 
 
-
-class ArticleChapter(ArticleOutlineBase, ChapterBase[ArticleSection]):
+class ArticleChapter(ChapterBase[ArticleSection]):
     """Thematic progression implementing research function."""
 
 
-
 class Article(
     Display,
     CensoredAble,
@@ -79,22 +85,17 @@ class Article(
     aiming to provide a comprehensive model for academic papers.
     """
 
-    abstract: str
-    """Contains a summary of the academic paper."""
+    def _as_prompt_inner(self) -> Dict[str, str]:
+        return {
+            "Original Article Briefing": self.referenced.referenced.referenced,
+            "Original Article Proposal": self.referenced.referenced.display(),
+            "Original Article Outline": self.referenced.display(),
+            "Original Article": self.display(),
+        }
 
-    title: str
-    """Represents the title of the academic paper."""
-
-    language: str
-    """Written language of the article. SHALL be aligned to the language of the article outline provided."""
-
-    def finalized_dump(self) -> str:
-        """Exports the article in `typst` format.
-
-        Returns:
-                str: Strictly formatted outline with typst formatting.
-        """
-        return "\n\n".join(c.to_typst_code() for c in self.chapters)
+    @override
+    def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
+        return super().iter_subsections()
 
     @classmethod
     def from_outline(cls, outline: ArticleOutline) -> "Article":
@@ -107,7 +108,7 @@ class Article(
             Article: The generated article.
         """
         # Set the title from the outline
-        article = Article(**outline.model_dump(include={"title", "abstract"}), chapters=[])
+        article = Article(**outline.model_dump(exclude={"chapters"}), chapters=[])
 
         for chapter in outline.chapters:
             # Create a new chapter
@@ -132,33 +133,16 @@ class Article(
             article.chapters.append(article_chapter)
         return article
 
-    @override
-    def iter_dfs(
-        self,
-    ) -> Generator[ArticleChapter | ArticleSection | ArticleSubsection, None, None]:
-        return super().iter_dfs()
-        
-    def deref(self, ref: ArticleRef) -> ArticleOutlineBase:
-        """Resolves a reference to the corresponding section or subsection in the article.
-
-        Args:
-            ref (ArticleRef): The reference to resolve.
-
-        Returns:
-            ArticleOutlineBase: The corresponding section or subsection.
-        """
-        return ok(ref.deref(self), f"{ref} not found in {self.title}")
-
     def gather_dependencies(self, article: ArticleOutlineBase) -> List[ArticleOutlineBase]:
         """Gathers dependencies for all sections and subsections in the article.
 
         This method should be called after the article is fully constructed.
         """
-        depends = [self.deref(a) for a in article.depend_on]
+        depends = [ok(a.deref(self)) for a in article.depend_on]
 
         supports = []
-        for a in self.iter_dfs():
-            if article in {self.deref(b) for b in a.support_to}:
+        for a in self.iter_dfs_rev():
+            if article in {ok(b.deref(self)) for b in a.support_to}:
                 supports.append(a)
 
         return list(set(depends + supports))
@@ -220,7 +204,7 @@ class Article(
         if all((not chapter, not section, not subsection)):
             raise ValueError("At least one of chapter, section, or subsection must be True.")
 
-        for component in self.iter_dfs():
+        for component in self.iter_dfs_rev():
             if not chapter and isinstance(component, ArticleChapter):
                 continue
             if not section and isinstance(component, ArticleSection):

fabricatio/models/extra/article_outline.py

@@ -1,45 +1,28 @@
 """A module containing the ArticleOutline class, which represents the outline of an academic paper."""
 
-from typing import Generator, List, Optional, Self, Tuple, Union, override
+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]):
+class ArticleSectionOutline(SectionBase[ArticleSubsectionOutline]):
     """A slightly more detailed research component specification for academic paper generation, Must contain subsections."""
 
 
-    def update_from_inner(self, other: Self) -> Self:
-        """Updates the current instance with the attributes of another instance."""
-        super().update_from_inner(other)
-        super(ArticleOutlineBase, self).update_from_inner(other)
-        return self
-
-
-class ArticleChapterOutline(ArticleOutlineBase, ChapterBase[ArticleSectionOutline]):
+class ArticleChapterOutline(ChapterBase[ArticleSectionOutline]):
     """Macro-structural unit implementing standard academic paper organization. Must contain sections."""
 
-    def update_from_inner(self, other: Self) -> Self:
-        """Updates the current instance with the attributes of another instance."""
-        super().update_from_inner(other)
-        super(ArticleOutlineBase, self).update_from_inner(other)
-        return self
-
 
 class ArticleOutline(
     Display,
@@ -48,140 +31,11 @@ class ArticleOutline(
     PersistentAble,
     ArticleBase[ArticleChapterOutline],
 ):
-    """A class representing the outline of an academic paper."""
-
-    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
+    """Outline of an academic paper, containing chapters, sections, subsections."""
 
-        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)
-
-    @override
-    def iter_dfs(
-        self,
-    ) -> Generator[ArticleChapterOutline | ArticleSectionOutline | ArticleSubsectionOutline, None, None]: 
-        return super().iter_dfs()
-    def find_illegal(self) -> Optional[Tuple[ArticleOutlineBase, str]]:
-        """Finds the first illegal component in the outline.
-
-        Returns:
-            Tuple[ArticleOutlineBase, str]: A tuple containing the illegal component and an error message.
-        """
-        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"
-            summary += component.introspect()
-            if summary:
-                return component, summary
-        return None
-
-    @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)