fabricatio 0.2.7.dev1__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
 
@@ -55,19 +58,23 @@ class GenerateArticleProposal(Action):
         **_,
     ) -> Optional[ArticleProposal]:
         if article_briefing is None and article_briefing_path is None and task_input is None:
-            logger.info("Task not approved, since ")
+            logger.error("Task not approved, since all inputs are None.")
             return None
-        if article_briefing_path is None and task_input:
-            article_briefing_path = await self.awhich_pathstr(
-                f"{task_input.briefing}\nExtract the path of file which contains the article briefing."
-            )
 
         return (
             await self.propose(
                 ArticleProposal,
                 briefing := (
                     article_briefing
-                    or safe_text_read(ok(article_briefing_path, "Could not find the path of file to read."))
+                    or safe_text_read(
+                        ok(
+                            article_briefing_path
+                            or await self.awhich_pathstr(
+                                f"{task_input.briefing}\nExtract the path of file which contains the article briefing."
+                            ),
+                            "Could not find the path of file to read.",
+                        )
+                    )
                 ),
                 **self.prepend_sys_msg(),
             )
@@ -85,13 +92,28 @@ class GenerateOutline(Action):
         article_proposal: ArticleProposal,
         **_,
     ) -> Optional[ArticleOutline]:
-        return (
-            await self.propose(
-                ArticleOutline,
-                article_proposal.as_prompt(),
-                **self.prepend_sys_msg(),
+        out = await self.propose(
+            ArticleOutline,
+            article_proposal.as_prompt(),
+            **self.prepend_sys_msg(),
+        )
+
+        manual = await self.draft_rating_manual(
+            topic=(
+                topic
+                := "Fix the internal referring error, make sure there is no more `ArticleRef` pointing to a non-existing article component."
+            ),
+        )
+        while err := out.resolve_ref_error():
+            logger.warning(f"Found error in the outline: \n{err}")
+            out = await self.correct_obj(
+                out,
+                reference=f"# Referring Error\n{err}",
+                topic=topic,
+                rating_manual=manual,
+                supervisor_check=False,
             )
-        ).update_ref(article_proposal)
+        return out.update_ref(article_proposal)
 
 
 class CorrectProposal(Action):
@@ -134,10 +156,42 @@ class GenerateArticle(Action):
     ) -> Optional[Article]:
         article: Article = Article.from_outline(article_outline).update_ref(article_outline)
 
-        for c, deps in article.iter_dfs_with_deps():
-            out = await self.correct_obj(
-                c, reference=f"{article_outline.referenced.as_prompt()}\n" + "\n".join(d.display() for d in deps)
+        writing_manual = await self.draft_rating_manual(
+            topic=(
+                topic_1
+                := "improve the content of the subsection to fit the outline. SHALL never add or remove any section or subsection, you can only add or delete paragraphs within the subsection."
+            ),
+        )
+        err_resolve_manual = await self.draft_rating_manual(
+            topic=(topic_2 := "this article component has violated the constrain, please correct it.")
+        )
+        for c, deps in article.iter_dfs_with_deps(chapter=False):
+            logger.info(f"Updating the article component: \n{c.display()}")
+
+            out = ok(
+                await self.correct_obj(
+                    c,
+                    reference=(
+                        ref := f"{article_outline.referenced.as_prompt()}\n" + "\n".join(d.display() for d in deps)
+                    ),
+                    topic=topic_1,
+                    rating_manual=writing_manual,
+                    supervisor_check=False,
+                ),
+                "Could not correct the article component.",
             )
+            while err := c.resolve_update_error(out):
+                logger.warning(f"Found error in the article component: \n{err}")
+                out = ok(
+                    await self.correct_obj(
+                        out,
+                        reference=f"{ref}\n\n# Violated Error\n{err}",
+                        topic=topic_2,
+                        rating_manual=err_resolve_manual,
+                        supervisor_check=False,
+                    ),
+                    "Could not correct the article component.",
+                )
 
             c.update_from(out)
         return article

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/capabilities/rating.py

@@ -10,6 +10,7 @@ from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.usages import LLMUsage
+from fabricatio.models.utils import override_kwargs
 from fabricatio.parser import JsonCapture
 from more_itertools import flatten, windowed
 from pydantic import NonNegativeInt, PositiveInt
@@ -126,13 +127,13 @@ class GiveRating(WithBriefing, LLMUsage):
         return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
 
     async def draft_rating_manual(
-        self, topic: str, criteria: Set[str], **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
+        self, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
     ) -> Optional[Dict[str, str]]:
         """Drafts a rating manual based on a topic and dimensions.
 
         Args:
             topic (str): The topic for the rating manual.
-            criteria (Set[str]): A set of dimensions for the rating manual.
+            criteria (Optional[Set[str]], optional): A set of criteria for the rating manual. If not specified, then this method will draft the criteria automatically.
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
@@ -148,6 +149,14 @@ class GiveRating(WithBriefing, LLMUsage):
                 return json_data
             return None
 
+        criteria = criteria or await self.draft_rating_criteria(
+            topic, **self.prepend_sys_msg(override_kwargs(dict(kwargs), default=None))
+        )
+
+        if criteria is None:
+            logger.error(f"Failed to draft rating criteria for topic {topic}")
+            return None
+
         return await self.aask_validate(
             question=(
                 TEMPLATE_MANAGER.render_template(

fabricatio/capabilities/review.py

@@ -1,6 +1,6 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
-from typing import List, Optional, Self, Set, Unpack, cast
+from typing import Dict, List, Optional, Self, Set, Unpack, cast
 
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
@@ -200,13 +200,14 @@ class Review(GiveRating, Propose):
             ReviewResult[Task[T]]: A review result containing identified problems and proposed solutions,
                 with a reference to the original task.
         """
-        return cast('ReviewResult[Task[T]]', await self.review_obj(task, **kwargs))
+        return cast("ReviewResult[Task[T]]", await self.review_obj(task, **kwargs))
 
     async def review_string(
         self,
         input_text: str,
         topic: str,
         criteria: Optional[Set[str]] = None,
+        rating_manual: Optional[Dict[str, str]] = None,
         **kwargs: Unpack[ValidateKwargs[ReviewResult[str]]],
     ) -> ReviewResult[str]:
         """Review a string based on specified topic and criteria.
@@ -219,6 +220,7 @@ class Review(GiveRating, Propose):
             topic (str): The subject topic for the review criteria.
             criteria (Optional[Set[str]], optional): A set of criteria for the review.
                 If not provided, criteria will be drafted automatically. Defaults to None.
+            rating_manual (Optional[Dict[str,str]], optional): A dictionary of rating criteria and their corresponding scores.
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
@@ -227,12 +229,13 @@ class Review(GiveRating, Propose):
         """
         default = None
         if "default" in kwargs:
+            # this `default` is the default for the `propose` method
             default = kwargs.pop("default")
 
         criteria = criteria or (await self.draft_rating_criteria(topic, **kwargs))
         if not criteria:
             raise ValueError("No criteria provided for review.")
-        manual = await self.draft_rating_manual(topic, criteria, **kwargs)
+        manual = rating_manual or await self.draft_rating_manual(topic, criteria, **kwargs)
 
         if default is not None:
             kwargs["default"] = default

fabricatio/decorators.py

@@ -177,3 +177,35 @@ def use_temp_module[**P, R](modules: ModuleType | List[ModuleType]) -> Callable[
         return _wrapper
 
     return _decorator
+
+
+def logging_exec_time[**P, R](func: Callable[P, R]) -> Callable[P, R]:
+    """Decorator to log the execution time of a function.
+
+    Args:
+        func (Callable): The function to be executed
+
+    Returns:
+        Callable: A decorator that wraps the function to log the execution time.
+    """
+    from time import time
+
+    if iscoroutinefunction(func):
+
+        @wraps(func)
+        async def _async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            start_time = time()
+            result = await func(*args, **kwargs)
+            logger.debug(f"Execution time of `{func.__name__}`: {time() - start_time:.2f} s")
+            return result
+
+        return _async_wrapper
+
+    @wraps(func)
+    def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        start_time = time()
+        result = func(*args, **kwargs)
+        logger.debug(f"Execution time of {func.__name__}: {(time() - start_time) * 1000:.2f} ms")
+        return result
+
+    return _wrapper

fabricatio/models/action.py

@@ -48,7 +48,7 @@ class Action(HandleTask, ProposeTask, Correct):
         self.description = self.description or self.__class__.__doc__ or ""
 
     @abstractmethod
-    async def _execute(self,*_, **cxt) -> Any:  # noqa: ANN002
+    async def _execute(self, *_, **cxt) -> Any:  # noqa: ANN002
         """Execute the action logic with the provided context arguments.
 
         This method must be implemented by subclasses to define the actual behavior.
@@ -147,6 +147,8 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         Args:
             task: The task to be processed.
         """
+        logger.info(f"Start execute workflow: {self.name}")
+
         await task.start()
         await self._init_context(task)
 
@@ -155,12 +157,11 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
             # Process each action in sequence
             for step in self._instances:
                 current_action = step.name
-                logger.debug(f"Executing step: {current_action}")
+                logger.info(f"Executing step: {current_action}")
 
                 # Get current context and execute action
                 context = await self._context.get()
                 act_task = create_task(step.act(context))
-
                 # Handle task cancellation
                 if task.is_cancelled():
                     act_task.cancel(f"Cancelled by task: {task.name}")
@@ -168,9 +169,10 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
 
                 # Update context with modified values
                 modified_ctx = await act_task
+                logger.success(f"Step execution finished: {current_action}")
                 await self._context.put(modified_ctx)
 
-            logger.info(f"Finished executing workflow: {self.name}")
+            logger.success(f"Workflow execution finished: {self.name}")
 
             # Get final context and extract result
             final_ctx = await self._context.get()
@@ -184,9 +186,9 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
 
             await task.finish(result)
 
-        except RuntimeError as e:
-            logger.error(f"Error during task: {current_action} execution: {e}")
-            logger.error(traceback.format_exc())
+        except Exception as e:  # noqa: BLE001
+            logger.critical(f"Error during task: {current_action} execution: {e}")
+            logger.critical(traceback.format_exc())
             await task.fail()
 
     async def _init_context[T](self, task: Task[T]) -> None:

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()