fabricatio 0.2.7.dev2__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.7.dev3__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/actions/article.py

@@ -6,7 +6,10 @@ from typing import Any, Callable, List, Optional
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.extra import Article, ArticleEssence, ArticleOutline, ArticleProposal
+from fabricatio.models.extra.article_essence import ArticleEssence
+from fabricatio.models.extra.article_main import Article
+from fabricatio.models.extra.article_outline import ArticleOutline
+from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.task import Task
 from fabricatio.models.utils import ok
 

fabricatio/actions/article_rag.py

@@ -0,0 +1,35 @@
+"""A module for writing articles using RAG (Retrieval-Augmented Generation) capabilities."""
+
+from typing import Optional
+
+from fabricatio.capabilities.rag import RAG
+from fabricatio.journal import logger
+from fabricatio.models.action import Action
+from fabricatio.models.extra.article_main import Article
+from fabricatio.models.extra.article_outline import ArticleOutline
+
+
+class GenerateArticleRAG(Action, RAG):
+    """Write an article based on the provided outline."""
+
+    output_key: str = "article"
+
+    async def _execute(self, article_outline: ArticleOutline, **cxt) -> Optional[Article]:
+        """Write an article based on the provided outline."""
+        logger.info(f"Writing an article based on the outline:\n{article_outline.title}")
+        refined_q = await self.arefined_query(article_outline.display())
+        return await self.propose(
+            Article,
+            article_outline.display(),
+            **self.prepend_sys_msg(f"{await self.aretrieve_compact(refined_q)}\n{self.briefing}"),
+        )
+
+
+class WriteArticleFineGrind(Action, RAG):
+    """Fine-grind an article based on the provided outline."""
+
+    output_key: str = "article"
+
+    async def _execute(self, article_outline: ArticleOutline, **cxt) -> Optional[Article]:
+        """Fine-grind an article based on the provided outline."""
+        logger.info(f"Fine-grinding an article based on the outline:\n{article_outline.title}")

fabricatio/models/extra/article_essence.py

@@ -0,0 +1,226 @@
+"""ArticleEssence: Semantic fingerprint of academic paper for structured analysis."""
+
+from typing import List
+
+from fabricatio.models.generic import Display, PrepareVectorization, ProposedAble
+from pydantic import BaseModel, Field
+
+
+class Equation(BaseModel):
+    """Mathematical formalism specification for research contributions.
+
+    Encodes equations with dual representation: semantic meaning and typeset-ready notation.
+    """
+
+    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."
+    """
+
+    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}"
+    """
+
+
+class Figure(BaseModel):
+    """Visual component specification for technical communication.
+
+    Combines graphical assets with structured academic captioning.Extracted from the article provided
+    """
+
+    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."
+    """
+
+    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."
+    """
+
+    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."
+    """
+
+
+class Highlightings(BaseModel):
+    """Technical showcase aggregator for research artifacts.
+
+    Curates core scientific components with machine-parseable annotations.
+    """
+
+    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.
+    """
+
+    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.
+    """
+
+    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, PrepareVectorization):
+    """Semantic fingerprint of academic paper for structured analysis.
+
+    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
+    """
+
+    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."""
+
+    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."""
+
+    publication_year: int
+    """Publication timestamp 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"""
+
+    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_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...'"""
+
+    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?'"""
+
+    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()

fabricatio/models/extra/article_main.py

@@ -0,0 +1,359 @@
+"""ArticleBase and ArticleSubsection classes for managing hierarchical document components."""
+
+from abc import abstractmethod
+from itertools import chain
+from typing import Generator, List, Self, Tuple, final
+
+from fabricatio.models.extra.article_outline import ArticleOutline, ArticleOutlineBase, ArticleRef
+from fabricatio.models.generic import CensoredAble, Display, PersistentAble, WithRef
+from fabricatio.models.utils import ok
+from loguru import logger
+
+
+class Paragraph(CensoredAble):
+    """Structured academic paragraph blueprint for controlled content generation."""
+
+    description: str
+    """Functional summary of the paragraph's role in document structure."""
+
+    writing_aim: List[str]
+    """Specific communicative objectives for this paragraph's content."""
+
+    sentences: List[str]
+    """List of sentences forming the paragraph's content."""
+
+
+class ArticleBase(CensoredAble, Display, ArticleOutlineBase, PersistentAble):
+    """Foundation for hierarchical document components with dependency tracking."""
+
+    @abstractmethod
+    def to_typst_code(self) -> str:
+        """Converts the component into a Typst code snippet for rendering."""
+
+    def _update_pre_check(self, other: Self) -> Self:
+        if not isinstance(other, self.__class__):
+            raise TypeError(f"Cannot update from a non-{self.__class__} instance.")
+        if self.title != other.title:
+            raise ValueError("Cannot update from a different title.")
+        return self
+
+    @abstractmethod
+    def resolve_update_error(self, other: Self) -> str:
+        """Resolve update errors in the article outline.
+
+        Returns:
+            str: Error message indicating update errors in the article outline.
+        """
+
+    @abstractmethod
+    def _update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+
+    @final
+    def update_from(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        return self._update_pre_check(other)._update_from_inner(other)
+
+    def __eq__(self, other: "ArticleBase") -> bool:
+        """Compares two ArticleBase objects based on their model_dump_json representation."""
+        return self.model_dump_json() == other.model_dump_json()
+
+    def __hash__(self) -> int:
+        """Calculates a hash value for the ArticleBase object based on its model_dump_json representation."""
+        return hash(self.model_dump_json())
+
+
+class ArticleSubsection(ArticleBase):
+    """Atomic argumentative unit with technical specificity."""
+
+    paragraphs: List[Paragraph]
+    """List of Paragraph objects containing the content of the subsection."""
+
+    def resolve_update_error(self, other: Self) -> str:
+        """Resolve update errors in the article outline."""
+        if self.title != other.title:
+            return f"Title `{other.title}` mismatched, expected `{self.title}`. "
+        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}")
+        self.paragraphs = other.paragraphs
+        return self
+
+    def to_typst_code(self) -> str:
+        """Converts the component into a Typst code snippet for rendering.
+
+        Returns:
+            str: Typst code snippet for rendering.
+        """
+        return f"=== {self.title}\n" + "\n\n".join("".join(p.sentences) for p in self.paragraphs)
+
+
+class ArticleSection(ArticleBase):
+    """Atomic argumentative unit with high-level specificity."""
+
+    subsections: List[ArticleSubsection]
+    """List of ArticleSubsection objects containing the content of the section."""
+
+    def resolve_update_error(self, other: Self) -> str:
+        """Resolve update errors in the article outline."""
+        if (s_len := len(self.subsections)) == 0:
+            return ""
+
+        if s_len != len(other.subsections):
+            return f"Subsections length mismatched, expected {len(self.subsections)}, got {len(other.subsections)}"
+
+        sub_sec_err_seq = [
+            out for s, o in zip(self.subsections, other.subsections, strict=True) if (out := s.resolve_update_error(o))
+        ]
+
+        if sub_sec_err_seq:
+            return "\n".join(sub_sec_err_seq)
+        return ""
+
+    def _update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        if len(self.subsections) == 0:
+            self.subsections = other.subsections
+            return self
+
+        for self_subsec, other_subsec in zip(self.subsections, other.subsections, strict=True):
+            self_subsec.update_from(other_subsec)
+        return self
+
+    def to_typst_code(self) -> str:
+        """Converts the section into a Typst formatted code snippet.
+
+        Returns:
+            str: The formatted Typst code snippet.
+        """
+        return f"== {self.title}\n" + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
+
+
+class ArticleChapter(ArticleBase):
+    """Thematic progression implementing research function."""
+
+    sections: List[ArticleSection]
+    """List of ArticleSection objects containing the content of the chapter."""
+
+    def resolve_update_error(self, other: Self) -> str:
+        """Resolve update errors in the article outline."""
+        if (s_len := len(self.sections)) == 0:
+            return ""
+
+        if s_len != len(other.sections):
+            return f"Sections length mismatched, expected {len(self.sections)}, got {len(other.sections)}"
+        sec_err_seq = [
+            out for s, o in zip(self.sections, other.sections, strict=True) if (out := s.resolve_update_error(o))
+        ]
+        if sec_err_seq:
+            return "\n".join(sec_err_seq)
+        return ""
+
+    def _update_from_inner(self, other: Self) -> Self:
+        """Updates the current instance with the attributes of another instance."""
+        if len(self.sections) == 0:
+            self.sections = other.sections
+            return self
+
+        for self_sec, other_sec in zip(self.sections, other.sections, strict=True):
+            self_sec.update_from(other_sec)
+        return self
+
+    def to_typst_code(self) -> str:
+        """Converts the chapter into a Typst formatted code snippet for rendering."""
+        return f"= {self.title}\n" + "\n\n".join(sec.to_typst_code() for sec in self.sections)
+
+
+class Article(Display, CensoredAble, WithRef[ArticleOutline], PersistentAble):
+    """Represents a complete academic paper specification, incorporating validation constraints.
+
+    This class integrates display, censorship processing, article structure referencing, and persistence capabilities,
+    aiming to provide a comprehensive model for academic papers.
+    """
+
+    article_language: str
+    """Written language of the article. SHALL be aligned to the language of the article outline provided."""
+
+    title: str
+    """Represents the title of the academic paper."""
+
+    abstract: str
+    """Contains a summary of the academic paper."""
+
+    chapters: List[ArticleChapter]
+    """Contains a list of chapters in the academic paper, each chapter is an ArticleChapter object."""
+
+    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)
+
+    @classmethod
+    def from_outline(cls, outline: ArticleOutline) -> "Article":
+        """Generates an article from the given outline.
+
+        Args:
+            outline (ArticleOutline): The outline to generate the article from.
+
+        Returns:
+            Article: The generated article.
+        """
+        # Set the title from the outline
+        article = Article(**outline.model_dump(include={"title", "abstract"}), chapters=[])
+
+        for chapter in outline.chapters:
+            # Create a new chapter
+            article_chapter = ArticleChapter(
+                sections=[],
+                **chapter.model_dump(exclude={"sections"}),
+            )
+            for section in chapter.sections:
+                # Create a new section
+                article_section = ArticleSection(
+                    subsections=[],
+                    **section.model_dump(exclude={"subsections"}),
+                )
+                for subsection in section.subsections:
+                    # Create a new subsection
+                    article_subsection = ArticleSubsection(
+                        paragraphs=[],
+                        **subsection.model_dump(),
+                    )
+                    article_section.subsections.append(article_subsection)
+                article_chapter.sections.append(article_section)
+            article.chapters.append(article_chapter)
+        return article
+
+    def chap_iter(self) -> Generator[ArticleChapter, None, None]:
+        """Iterates over all chapters in the article.
+
+        Yields:
+            ArticleChapter: Each chapter in the article.
+        """
+        yield from self.chapters
+
+    def section_iter(self) -> Generator[ArticleSection, None, None]:
+        """Iterates over all sections in the article.
+
+        Yields:
+            ArticleSection: Each section in the article.
+        """
+        for chap in self.chapters:
+            yield from chap.sections
+
+    def subsection_iter(self) -> Generator[ArticleSubsection, None, None]:
+        """Iterates over all subsections in the article.
+
+        Yields:
+            ArticleSubsection: Each subsection in the article.
+        """
+        for sec in self.section_iter():
+            yield from sec.subsections
+
+    def iter_dfs(self) -> Generator[ArticleBase, None, None]:
+        """Performs a depth-first search (DFS) through the article structure.
+
+        Returns:
+            Generator[ArticleBase]: Each component in the article structure.
+        """
+        for chap in self.chap_iter():
+            for sec in chap.sections:
+                yield from sec.subsections
+                yield sec
+            yield chap
+
+    def deref(self, ref: ArticleRef) -> ArticleBase:
+        """Resolves a reference to the corresponding section or subsection in the article.
+
+        Args:
+            ref (ArticleRef): The reference to resolve.
+
+        Returns:
+            ArticleBase: The corresponding section or subsection.
+        """
+        return ok(ref.deref(self), f"{ref} not found in {self.title}")
+
+    def gather_dependencies(self, article: ArticleBase) -> List[ArticleBase]:
+        """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]
+
+        supports = []
+        for a in self.iter_dfs():
+            if article in {self.deref(b) for b in a.support_to}:
+                supports.append(a)
+
+        return list(set(depends + supports))
+
+    def gather_dependencies_recursive(self, article: ArticleBase) -> List[ArticleBase]:
+        """Gathers all dependencies recursively for the given article.
+
+        Args:
+            article (ArticleBase): The article to gather dependencies for.
+
+        Returns:
+            List[ArticleBase]: A list of all dependencies for the given article.
+        """
+        q = self.gather_dependencies(article)
+
+        deps = []
+        while q:
+            a = q.pop()
+            deps.extend(self.gather_dependencies(a))
+
+        deps = list(
+            chain(
+                filter(lambda x: isinstance(x, ArticleChapter), deps),
+                filter(lambda x: isinstance(x, ArticleSection), deps),
+                filter(lambda x: isinstance(x, ArticleSubsection), deps),
+            )
+        )
+
+        # Initialize result containers
+        formatted_code = ""
+        processed_components = []
+
+        # Process all dependencies
+        while deps:
+            component = deps.pop()
+            # Skip duplicates
+            if (component_code := component.to_typst_code()) in formatted_code:
+                continue
+
+            # Add this component
+            formatted_code += component_code
+            processed_components.append(component)
+
+        return processed_components
+
+    def iter_dfs_with_deps(
+        self, chapter: bool = True, section: bool = True, subsection: bool = True
+    ) -> Generator[Tuple[ArticleBase, List[ArticleBase]], None, None]:
+        """Iterates through the article in a depth-first manner, yielding each component and its dependencies.
+
+        Args:
+            chapter (bool, optional): Whether to include chapter components. Defaults to True.
+            section (bool, optional): Whether to include section components. Defaults to True.
+            subsection (bool, optional): Whether to include subsection components. Defaults to True.
+
+        Yields:
+            Tuple[ArticleBase, List[ArticleBase]]: Each component and its dependencies.
+        """
+        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():
+            if not chapter and isinstance(component, ArticleChapter):
+                continue
+            if not section and isinstance(component, ArticleSection):
+                continue
+            if not subsection and isinstance(component, ArticleSubsection):
+                continue
+            yield component, (self.gather_dependencies_recursive(component))